Formations — 1 037 leçons en français

Accueil › TypeScript › Comment l'inférence choisit

Comment l'inférence choisit

Les génériquesintermediaire

L'inférence n'est pas magique : le compilateur collecte des candidats aux endroits où le paramètre de type apparaît, puis choisit.

Un seul candidat

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

premier([1, 2, 3]);               // un site, un candidat : T = number

Plusieurs candidats

function paire<T>(a: T, b: T): T[] {
  return [a, b];
}

paire(1, 2);                      // T = number
paire(1, "x");                    // T = string | number — accepté !

Le compilateur cherche un type qui couvre les deux. C'est commode, et c'est une source de bogues silencieux : un tableau censé être homogène accepte un mélange.

// ✅ l'intention devient explicite
function paire<A, B>(a: A, b: B): [A, B]

L'élargissement

const mode = "sombre";            // type "sombre"
let autre = "sombre";             // type string — élargi

function appliquer<T>(m: T): T { return m; }
appliquer(mode);                  // "sombre"
appliquer(autre);                 // string

C'est la cause numéro un des inférences décevantes. La parade :

appliquer("sombre" as const);
function appliquer<T extends string>(m: T): T   // garde le littéral

Le typage contextuel

const noms = clients.map((c) => c.nom);
//                        ^ typé Client, sans annotation

Le compilateur connaît la signature attendue par map et en déduit le type du paramètre. C'est ce qui rend le code fonctionnel supportable.

Les termes à connaître

Site d'inférence

Chaque endroit où le paramètre de type apparaît dans les paramètres de la fonction. Le compilateur y collecte des candidats.

Candidat

Un type déduit d'un argument. S'il y en a plusieurs, le compilateur cherche un type qui les couvre tous.

Élargissement

Un littéral "ok" devient string dans un contexte mutable. C'est la raison numéro un des inférences décevantes.

Position contextuelle

Un paramètre de fonction passée en argument reçoit son type du contexte. C'est ce qui évite d'annoter les callbacks.

Inférence en deux passes

Le compilateur fixe d'abord les paramètres de type déductibles des arguments simples, puis s'en sert pour typer les fonctions passées.

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.