Formations — 1 037 leçons en français

Accueil › TypeScript › Inférence

Inférence — entretien TypeScript

14 questions posées en entretien, avec la bonne réponse et son explication.

Où faut-il annoter, si l'inférence fonctionne ?

  1. Sur les frontières publiques : paramètres et retours exportés ✓
  2. Partout, pour que le code se lise sans éditeur
  3. Nulle part : l'inférence est toujours suffisante
  4. Sur les variables locales, et jamais sur les signatures

Pourquoi : Une annotation de frontière est un contrat : elle fixe ce que les appelants peuvent attendre et fait signaler l'erreur dans la fonction fautive plutôt que chez son consommateur. À l'intérieur d'une fonction, l'inférence est exacte et sans maintenance ; une annotation locale redondante se périme et déplace l'erreur loin de sa cause. Les paramètres de fonctions nommées, eux, s'annotent toujours — sinon TS7006.

Niveau confirme

Quel est le type inféré dans chaque cas ?

const a = "admin";
let b = "admin";
const c = { role: "admin" };
  1. `"admin"`, `string`, `{ role: string }` ✓
  2. `string`, `string`, `{ role: string }`
  3. `"admin"`, `"admin"`, `{ role: "admin" }`
  4. `string`, `"admin"`, `{ role: "admin" }`

Pourquoi : Un « const » de primitif garde son type littéral, un « let » est élargi au primitif, et une propriété d'objet est élargie même dans un « const » puisqu'elle reste modifiable. Conséquence : « a » passe à une fonction qui attend « 'admin' | 'lecteur' », « b » et « c.role » sont refusés avec TS2345. « as const » est la réponse au cas de l'objet.

Niveau confirme

Pourquoi préférer « satisfies Theme » à l'annotation « : Theme » sur un objet de configuration ?

  1. « satisfies » vérifie la conformité sans élargir le type inféré de l'objet ✓
  2. « satisfies » autorise les propriétés inconnues, l'annotation non
  3. « satisfies » agit à l'exécution, l'annotation seulement à la compilation
  4. Les deux sont équivalents, « satisfies » est seulement plus récent

Pourquoi : L'annotation remplace le type de la valeur par le type déclaré : avec un « Record<string, …> », les clés réelles disparaissent et « keyof typeof » ne donne plus d'union utilisable, ni l'autocomplétion. « satisfies » contrôle la conformité et conserve le type exact de l'objet écrit. Les propriétés en trop sont refusées dans les deux cas : ce n'est pas là que se situe la différence.

Niveau senior

Quel est le risque de laisser le type de retour d'une fonction exportée inféré ?

  1. La signature publique change silencieusement quand le corps change ✓
  2. Le compilateur refuse d'exporter une fonction sans retour annoté
  3. Le type inféré devient « any » hors du module
  4. La compilation devient notablement plus lente

Pourquoi : Un « ?? null » ajouté dans le corps fait passer le retour de « Client | undefined » à « Client | null », et la rupture se constate chez les appelants, pas dans le fichier modifié. Pire : un appelant qui écrivait « if (!client) » continue de compiler tout en ayant changé de sens. Annoter le retour force la décision à l'endroit où elle se prend. À l'intérieur d'un module, l'inférence reste préférable.

Niveau senior

Que déduit le compilateur quand deux arguments de types différents alimentent le même paramètre de type ?

  1. Un type qui couvre les deux candidats, souvent leur union ✓
  2. Le type du premier argument, et il refuse le second
  3. any
  4. Il refuse l'appel : les candidats doivent être identiques

Pourquoi : Deux sites d'inférence produisent deux candidats, et le compilateur retient un type qui les englobe. C'est commode, et c'est aussi une source de bogues silencieux : un tableau censé être homogène accepte alors un mélange. Deux paramètres de type distincts rendent l'intention explicite.

Niveau confirme

Pourquoi un littéral de chaîne devient-il souvent string à l'inférence ?

  1. Par élargissement : hors contexte figé, un littéral mutable est élargi ✓
  2. Parce que le paramètre de type n'est pas contraint
  3. Parce que la fonction n'a qu'un paramètre
  4. C'est faux : le littéral est toujours conservé

Pourquoi : Dès que la valeur peut changer — un let, une propriété d'objet modifiable — garder le type littéral serait faux, donc le compilateur élargit. Les deux parades sont une assertion de constance sur l'argument, ou une contrainte sur le paramètre de type, qui demande au compilateur de garder le littéral.

Niveau confirme

Pourquoi n'annote-t-on pas le paramètre d'une fonction passée à map ?

  1. Il est en position contextuelle : son type vient de la signature attendue ✓
  2. Parce que map utilise any en interne
  3. Parce que les paramètres de rappel valent toujours unknown
  4. Parce que l'annotation est interdite à cet endroit

Pourquoi : Le compilateur connaît la signature que map attend et en déduit le type du paramètre : c'est le typage contextuel, et c'est ce qui rend le code fonctionnel supportable en TypeScript. L'annoter n'est pas une erreur, mais cela fige — si le type de la collection change, l'annotation devient fausse au lieu de suivre.

Niveau junior

Pourquoi placer les données avant la fonction dans une signature générique ?

  1. Parce que l'inférence se fait en deux passes : le type déduit des données sert ensuite à typer la fonction ✓
  2. Par convention de lisibilité uniquement
  3. Parce qu'une fonction ne peut pas être le premier paramètre
  4. Pour permettre les paramètres optionnels

Pourquoi : 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. Dans l'ordre inverse, le paramètre du rappel est typé avant que le paramètre de type soit connu, et devient implicitement any. L'ordre des paramètres est donc une décision de conception, pas un détail de style.

Niveau senior

Dans un message d'erreur de compilation imbriqué sur plusieurs lignes, quelle ligne lire en premier ?

  1. La dernière : les messages s'imbriquent du général au précis ✓
  2. La première, qui résume tout
  3. Celle qui contient un code d'erreur
  4. Peu importe, elles répètent la même chose

Pourquoi : La première ligne dit seulement que deux types ne sont pas compatibles, ce qu'on savait déjà ; les suivantes descendent propriété par propriété jusqu'à la cause exacte — une clé manquante, un type de champ divergent. Prendre l'habitude de lire de bas en haut fait gagner un temps considérable sur les types composés.

Niveau senior

Pourquoi une contrainte « extends string » conserve-t-elle le type littéral de l'argument ?

  1. Parce que la contrainte indique au compilateur que la précision du littéral est l'objet du générique ✓
  2. Parce que la fonction rend le paramètre de type
  3. Parce que l'argument est une constante
  4. C'est faux : le littéral est élargi dans tous les cas

Pourquoi : Sans contrainte, le compilateur élargit le littéral par défaut ; avec la contrainte, il comprend que la précision est recherchée et la conserve. C'est l'usage le plus courant d'une contrainte au quotidien, et il dispense l'appelant d'écrire une assertion de constance à chaque appel.

Niveau confirme

Que déduit le compilateur quand aucun argument ne permet de déduire un paramètre de type contraint ?

  1. La contrainte elle-même ✓
  2. any
  3. never
  4. Il refuse de compiler

Pourquoi : Le repli sur la contrainte explique les inférences qui semblent sorties de nulle part : un paramètre contraint à une forme et jamais déduit vaut exactement cette forme, et le code compile en perdant silencieusement toute précision. C'est le bon moment pour annoter explicitement, ou pour se demander si le générique sert vraiment.

Niveau senior

Pourquoi l'ordre des paramètres de type importe-t-il quand l'un contraint l'autre ?

  1. Un paramètre contraint par un autre doit venir après lui pour que sa contrainte soit résoluble ✓
  2. Parce que les chevrons se lisent de droite à gauche
  3. Parce que seul le premier paramètre est inféré
  4. L'ordre n'a aucune importance

Pourquoi : Placer la clé avant l'objet est accepté à la déclaration mais produit des inférences dégradées, parce que la clé est résolue alors que l'objet n'est pas encore connu. L'habitude à prendre est la même que pour les paramètres de valeur : ce dont les autres dépendent vient d'abord.

Niveau senior

Que déduit le compilateur d'un appel générique sur un tableau vide ?

  1. never, faute de candidat — il faut annoter explicitement ✓
  2. unknown
  3. any
  4. Le type attendu par l'appelant

Pourquoi : Aucun élément, aucun candidat, donc le type le plus bas. Le code compile et devient inutilisable : on ne peut rien ajouter à un tableau de never. Trois situations imposent l'annotation explicite — la collection vide, l'absence d'argument, et le cas où l'on veut volontairement un type plus large que celui déduit.

Niveau confirme

Pourquoi accepter un tableau en lecture seule comme paramètre d'une fonction générique ?

  1. Pour accepter aussi les tableaux figés, qui ne sont pas assignables à un tableau mutable ✓
  2. Pour améliorer les performances
  3. Parce que les tableaux mutables sont interdits en paramètre
  4. Pour permettre l'inférence du type des éléments

Pourquoi : Un tableau figé par une assertion de constance n'est pas assignable à un tableau mutable, et l'argument serait refusé. Déclarer le paramètre en lecture seule accepte les deux formes et annonce au passage que la fonction ne modifie pas ce qu'elle reçoit — ce qui est presque toujours ce que l'on veut dire.

Niveau confirme

S'entraîner sur ces questions, chronométré →