Qu'est-ce que les contraintes génériques ?

Question

Accepted Answer

Une **contrainte générique** (`T extends ...`) restreint les types qu'un paramètre générique peut être, vous permettant d'utiliser en toute sécurité certaines propriétés ou méthodes sur celui-ci. Sans contrainte, un générique pourrait être *n'importe quoi*, vous ne pouvez donc pas supposer qu'il a des membres. ```ts // ❌ without a constraint, you can't access .length — T might be a number function longestBad(a: T, b: T) { return a.length > b.length ? a : b; // Error: 'length' does not exist on 'T' } // ✅ constrain T to things that HAVE a length function longest(a: T, b: T): T { return a.length > b.length ? a : b; } longest("abc", "de"); // ✅ strings have length longest([1, 2], [3]); // ✅ arrays have length longest(1, 2); // ❌ numbers have no length ``` La contrainte est une *promesse* : "`T` aura toujours au moins cette forme," ce qui permet au compilateur d'autoriser `.length` tout en gardant `T` précis (le type de retour est le type tableau/chaîne réel, pas la contrainte). ## Contraindre aux clés (très courant) ```ts function pluck(obj: T, key: K): T[K] { return obj[key]; } ``` `K extends keyof T` garantit que `key` est une propriété réelle de `obj` — et `T[K]` retourne son type exact. ## Paramètres de type par défaut ```ts interface Box { value: T; } // T defaults to string if not specified ``` ## Pourquoi c'est important Les contraintes sont l'équilibre entre flexibilité et sécurité : elles permettent au code générique de compter sur une forme minimale (a `.length`, a la clé `K`, étend une base) tout en préservant le type spécifique de l'appelant. Elles sont essentielles pour les fonctions utilitaires, l'accès type-safe aux objets et tout générique qui doit *faire* quelque chose avec son paramètre de type.