Formations — 1 037 leçons en français

Accueil › TypeScript › Pourquoi un générique

Pourquoi un générique

Les génériquesintermediaire

Le problème

function premier(liste: any[]): any {
  return liste[0];
}

const n = premier([1, 2, 3]);
n.toUpperCase();          // ✅ accepté — et explose à l'exécution

any accepte tout et rend tout. L'information est perdue à la frontière de la fonction.

La solution

function premier<T>(liste: T[]): T | undefined {
  return liste[0];
}

const n = premier([1, 2, 3]);      // number | undefined
n.toUpperCase();                    // ❌ TS2339 : « toUpperCase » n'existe pas sur « number »

Le générique dit : « je rends le même type que celui qu'on m'a donné ». C'est une relation, pas un type.

On n'écrit pas les chevrons

premier([1, 2, 3]);               // T déduit : number
premier(["a", "b"]);              // T déduit : string
premier<string>([]);              // explicite, parce qu'il n'y a rien à déduire

L'inférence couvre la quasi-totalité des appels. C'est ce qui rend les génériques supportables.

Ce qui n'existe pas à l'exécution

function creer<T>(): T {
  if (T === String) …              // ❌ TS2693 : « T » n'est qu'un type
}

Un paramètre de type est effacé à la compilation. Il ne reste rien.

Le corollaire qui compte

async function lire<T>(url: string): Promise<T> {
  const r = await fetch(url);
  return r.json();                 // ⚠️ aucune vérification
}

const client = await lire<Client>("/api/clients/1");   // un mensonge confortable

Le serveur peut renvoyer n'importe quoi. Le générique ne valide rien : il se contente de décrire ce qu'on espère.

Les termes à connaître

Générique

Un paramètre de type. La fonction ou le type ne décide pas du type, l'appelant le fournit — ou le compilateur le déduit.

Relation préservée

Ce qu'un générique exprime et qu'any détruit : le lien entre le type qui entre et le type qui sort.

Inférence des arguments

Le compilateur déduit le paramètre de type à partir des arguments passés. On écrit donc rarement les chevrons à l'appel.

Paramètre de type

Le nom entre chevrons dans la déclaration. T par convention, mais un nom parlant vaut mieux dès qu'il y en a deux.

Instanciation

Le remplacement du paramètre de type par un type concret, à chaque appel. Il n'en reste rien à l'exécution.

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.