Aller au contenu
Makersquad

TypeScript 5.5 est sorti

par Makersquad ·

Logo de TypeScript sur fond dégradé

Date de sortie : 20 juin 2024

Mis à jour le 17 novembre 2026

Documentation officielle : Announcing TypeScript 5.5

TypeScript 5.5 rend le compilateur encore plus intelligent. Les type predicates sont maintenant inférés automatiquement, votre filter(x => x != null) retourne enfin le bon type. La vérification syntaxique des littéraux de regex attrape des erreurs avant le runtime.

Les nouveautés principales

Type predicates inférés, le compilateur lit dans vos pensées

TypeScript infère automatiquement les type guards :

const numbers = [1, 2, null, 3, undefined, 4];

// Avant : filter retourne (number | null | undefined)[]
const filtered = numbers.filter(x => x !== null && x !== undefined);

// Après : la fonction passée à filter est inférée comme
// un type predicate (x is number), donc le résultat est number[]

L’inférence ne s’applique que si la fonction n’a pas de type de retour explicite, n’a qu’une seule instruction return, ne modifie pas son paramètre et retourne une expression booléenne liée à un raffinement du paramètre. Un test de véracité comme !!score ne convient généralement pas : la valeur 0 rend le résultat ambigu. Un prédicat inféré peut aussi casser du code qui comptait sur un type plus large, ce qui demande alors une annotation explicite.

Narrowing sur les accès indexés constants

Le narrowing fonctionne avec les accès par index quand ni l’objet ni la clé ne sont modifiés, y compris avec une clé de type string :

function f1(obj: Record<string, unknown>, key: string) {
    if (typeof obj[key] === "string") {
        // Maintenant accepté, c'était une erreur avant 5.5
        obj[key].toUpperCase();
    }
}

Vérification syntaxique des regex

TypeScript vérifie maintenant les erreurs de syntaxe de base des littéraux d’expressions régulières, comme une parenthèse fermante non échappée :

// Erreur : parenthèse fermante en trop
const re = /@robot(\s+(please|immediately)))? do some task/;

Il signale aussi les références arrière vers des groupes inexistants, et les groupes nommés ou certains drapeaux quand la cible ECMAScript est trop ancienne. Les chaînes passées à new RegExp ne sont pas vérifiées.

Isolated declarations

Avec --isolatedDeclarations, TypeScript signale les exports qui n’ont pas les annotations de type explicites dont un outil aurait besoin pour générer les fichiers de déclaration sans vérificateur de types complet. Il demande declaration ou composite et ne change pas l’émission de TypeScript lui-même :

{
  "compilerOptions": {
    "isolatedDeclarations": true,
    "declaration": true
  }
}

Cette option pose les bases de générateurs de .d.ts plus rapides, voire parallèles, dans des outils tiers. Certains motifs, comme les propriétés calculées dans les classes, n’étaient pas pris en charge à la sortie de la 5.5.

Support des méthodes Set ECMAScript

Typage pour les nouvelles méthodes Set :

const setA = new Set([1, 2, 3]);
const setB = new Set([2, 3, 4]);

setA.union(setB);        // Set {1, 2, 3, 4}
setA.intersection(setB); // Set {2, 3}
setA.difference(setB);   // Set {1}

JSDoc @import

Importer des types en JSDoc :

/** @import { SomeType } from "some-module" */

/** @param {SomeType} value */
function process(value) {
  return value;
}

À retenir

TypeScript 5.5 réduit le nombre de cas où vous devez aider le compilateur. L’inférence des type predicates à elle seule va nettoyer beaucoup de code. La vérification des regex reste un filet de sécurité utile, même si elle ne couvre que les littéraux.

Échanger avec un expert TypeScript

De l’idée au marché. Makersquad conçoit des logiciels sur mesure, pensés pour durer, avec de petites équipes d’experts autonomes. Depuis 2018.