Les génériques vous permettent d'écrire du code réutilisable paramétrée par un type — une "variable de type" remplie lors de l'utilisation du code. Ils vous donnent la réutilisabilité sans perdre la sécurité de type (l'alternative, any, la perd).
(): { arr[]; }
first<T>(: T[]): T { arr[]; }
n = ([, , ]);
s = ([, ]);
T est un espace réservé ; TypeScript l'infère à partir de l'argument, donc le type de retour est précis — first([1,2]) donne un number, pas any.
interface ApiResponse<T> { data: T; status: number; }
const res: ApiResponse<User> = await getUser(); // res.data is User
class Box<T> {
constructor(private value: T) {}
get(): T { return this.value; }
}
const box = new Box(123); // Box<number>
function pair<K, V>(k: K, v: V): [K, V] { return [k, v]; }
pair("id", 42); // [string, number]
Les génériques alimentent presque toutes les abstractions réutilisables dans TypeScript : Array<T>, Promise<T>, Map<K,V>, useState<T> de React, les utilitaires de récupération de données et les collections.
Ils permettent à une seule implémentation de fonctionner pour de nombreux types tout en conservant l'intégralité des informations de type d'un bout à l'autre — la relation entre les types d'entrée et de sortie est conservée, pas effacée.