Formations — 1 037 leçons en français

Accueil › TypeScript › extends comme contrainte

extends comme contrainte

Contraintes et inférenceintermediaire

Le problème

function indexer<T>(elements: T[]): Map<string, T> {
  return new Map(elements.map((e) => [e.id, e]));
  //                               ^^^^ ❌ TS2339 : « id » n'existe pas sur « T »
}

T peut être n'importe quoi — un nombre, une chaîne. Le compilateur a raison de refuser.

La contrainte

function indexer<T extends { id: string }>(elements: T[]): Map<string, T> {
  return new Map(elements.map((e) => [e.id, e]));     // ✅
}

indexer([{ id: "a", nom: "Astra" }]);     // ✅ propriétés en plus : acceptées
indexer([1, 2, 3]);                        // ❌ TS2345

extends ici ne dérive pas : il exige.

Contraindre n'est pas fixer

// ❌ fixe : on perd le type réel
function indexer(elements: { id: string }[]): Map<string, { id: string }>

// ✅ contraint : on garde le type réel
function indexer<T extends { id: string }>(elements: T[]): Map<string, T>

Dans la première version, le résultat a oublié que c'étaient des Client. Dans la seconde, Map<string, Client>.

Le même mot, deux rôles

interface Admin extends Utilisateur { … }    // hérite
function f<T extends Utilisateur>(x: T)      // exige

Une contrainte se justifie par ce qu'elle permet

// ❌ n'exige presque rien, ne garantit presque rien
function f<T extends object>(x: T)

// ✅ exige ce que le code utilise
function f<T extends { creeLe: string }>(x: T)

Si une contrainte ne débloque rien à l'intérieur, elle ne fait que restreindre les appelants.

Les termes à connaître

Contrainte

T extends Forme : le paramètre de type n'accepte que ce qui est compatible avec Forme. C'est une exigence, pas un héritage.

Borne supérieure

Ce que la contrainte garantit : à l'intérieur de la fonction, T a au moins les membres de la contrainte.

extends en deux sens

Dans une déclaration de classe ou d'interface, extends hérite. Entre chevrons, il contraint. Même mot, deux rôles.

Contrainte oubliée

Utiliser une propriété de T sans l'avoir contraint. Le compilateur refuse — TS2339 — et il a raison.

Contrainte trop large

T extends object ou T extends any n'exige presque rien et ne garantit donc presque rien. Une contrainte vague est une contrainte inutile.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.