TypeScript 4.0 est sorti

Microsoft vient de publier TypeScript 4.0, et cette version apporte son lot de nouveautés intéressantes. Voici ce qui change pour vous.

Documentation officielle : https://devblogs.microsoft.com/typescript/announcing-typescript-4-0/

Ce qui change vraiment

Variadic tuple types

Enfin, les spreads dans les tuples peuvent être génériques. Concrètement, vous pouvez maintenant écrire des fonctions plus expressives :

function concat<T extends unknown[], U extends unknown[]>(
  a: T, b: U
): [...T, ...U] {
  return [...a, ...b];
}

const result = concat([1, 2] as const, ["hello"] as const);
// Type: [1, 2, "hello"]

Labeled tuple elements

Fini les tuples cryptiques ! Vous pouvez maintenant nommer leurs éléments pour rendre le code plus lisible :

type Range = [start: number, end: number];
type Point = [x: number, y: number, z?: number];

function plot([x, y]: Point) {
  // Bonus : les labels apparaissent dans l'autocomplétion de votre IDE
}

Opérateurs d’assignation logique

Trois petits nouveaux qui vont vous simplifier la vie :

// &&=
a &&= b;  // a = a && b (assigne si truthy)

// ||=
a ||= b;  // a = a || b (assigne si falsy)

// ??=
a ??= b;  // a = a ?? b (assigne si null/undefined)

// Exemple pratique
user.name ??= "Anonymous";

unknown sur les clauses catch

Une bonne nouvelle pour la sécurité : activez useUnknownInCatchVariables et vos erreurs seront mieux typées :

try {
  // ...
} catch (err) {
  // err est maintenant unknown (et non plus any)
  if (err instanceof Error) {
    console.log(err.message);
  }
}

Inférence des propriétés de classe

Bonne nouvelle : moins d’annotations à écrire ! TypeScript infère maintenant les types depuis le constructeur :

class Point {
  // Plus besoin d'annoter, TypeScript le déduit du constructeur
  x;
  y;

  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }
}

Et aussi…

• Support des custom JSX factories (jsxFragmentFactory)
• Marquage des fonctions obsolètes avec @deprecated en JSDoc
• Un mode sémantique partiel pour un démarrage plus rapide
• Des outils de refactoring automatiques vers l’optional chaining