Accueil › TypeScript › Types mappés et littéraux de gabarit
Types mappés et littéraux de gabarit — entretien TypeScript
8 questions posées en entretien sur 3 sujets, avec la bonne réponse et son explication.
Types mappés
Quelle est la forme d'un type mappé ?
- `{ [K in keyof T]: T[K] }` — une boucle sur les clés d'un type ✓
- `{ K: keyof T }`
- `type M<T> = T extends object ? T : never`
- `{ [key: string]: T }`
Pourquoi : Trois pièces et rien d'autre : une union de clés, la boucle `in`, et un corps. La quatrième proposition est une signature d'index, qui accepte n'importe quelle clé au lieu de reprendre celles d'un type précis — c'est la confusion la plus courante. Un type mappé produit des clés nommées, que l'éditeur sait compléter.
Niveau junior
Le corps d'un type mappé doit-il dépendre de T[K] ?
- Non : seules les clés viennent de T, le corps est libre ✓
- Oui, sinon le mappage ne compile pas
- Oui, sauf si on écrit `any`
- Non, mais le résultat est alors une signature d'index
Pourquoi : `{ [K in keyof T]: string }` reprend les clés de `T` et donne `string` à toutes. C'est le patron de tous les types de formulaire : prendre un modèle et en dériver un objet de messages d'erreur, d'états de validation ou de libellés, avec la garantie que les clés restent synchronisées avec le modèle.
Niveau confirme
Pourquoi faut-il écrire littéralement « K in keyof T » et non passer par un paramètre de clés ?
- Parce que seule cette écriture est homomorphe et conserve tableaux, tuples et modificateurs ✓
- Parce que l'autre écriture ne compile pas
- Parce que keyof T est plus rapide à calculer
- Parce qu'un paramètre de clés interdit la clause as
Pourquoi : Un mappage écrit littéralement `[K in keyof T]` reçoit un traitement spécial : `Partial<string[]>` reste un tableau, `Partial<[a, b]>` reste un tuple. Avec `<T, K extends keyof T = keyof T>` et `[P in K]`, le même code produit un objet portant les clés d'un tableau. La régression est silencieuse et ne se voit qu'au premier `.map` perdu.
Niveau senior
Littéraux de gabarit
Quelle différence entre Capitalize et Uppercase ?
- Capitalize ne transforme que le premier caractère, Uppercase toute la chaîne ✓
- Aucune, Capitalize est un alias
- Capitalize agit sur les clés, Uppercase sur les valeurs
- Uppercase ne fonctionne que sur les unions
Pourquoi : La confusion produit des noms d'accesseurs comme `getNOMCLIENT` au lieu de `getNomClient`, et les deux compilent. Ces quatre types — `Uppercase`, `Lowercase`, `Capitalize`, `Uncapitalize` — sont marqués `intrinsic` dans la bibliothèque standard : ils ne sont pas écrits en TypeScript, le compilateur les implémente en interne.
Niveau junior
Combien de membres produit un gabarit croisant deux unions de dix membres ?
type A = "a1" | "a2" | /* … */ "a10";
type B = "b1" | "b2" | /* … */ "b10";
type R = `${A}-${B}`;
- Cent — le produit cartésien des deux unions ✓
- Vingt — l'union des deux
- Dix
- Un seul, c'est un motif
Pourquoi : Un gabarit distribue sur chacune de ses unions et matérialise le produit. La distinction qui compte : un trou rempli d'une union est développé membre par membre, alors qu'un trou `string` ou `number` reste un motif vérifié à l'assignation, sans coût. Le compilateur refuse les unions au-delà de cent mille membres.
Niveau confirme
Renommage
Comment supprime-t-on une clé dans un type mappé ?
- En la renommant en `never` avec la clause `as` ✓
- En donnant à son corps le type `never`
- Avec le modificateur `-key`
- Avec `delete` dans le corps du mappage
Pourquoi : Une clé renommée en `never` disparaît : c'est l'unique mécanisme de filtrage des types mappés. La deuxième proposition est la faute classique — elle laisse une propriété obligatoire de type `never`, qu'aucune valeur n'habite, donc plus aucun objet littéral n'est assignable au type produit et l'erreur apparaît loin de sa cause.
Niveau confirme
Qu'affiche ce code ?
type Filtre<T> = { [K in keyof T]: K extends "id" ? never : T[K] };
type R = Filtre<{ id: number; nom: string }>;
- `{ id: never; nom: string }` — la clé reste, inhabitable ✓
- `{ nom: string }` — la clé est supprimée
- `never`
- Une erreur de compilation
Pourquoi : Le `never` est dans le corps, pas dans la clé : la propriété reste obligatoire avec un type qu'aucune valeur n'habite. Aucun objet littéral n'est donc assignable à `R`, et le message d'erreur parlera de la clé `id` sans expliquer pourquoi. La forme correcte renomme la clé — `as K extends "id" ? never : K`.
Niveau senior
Pourquoi écrit-on « string & K » dans un gabarit de renommage ?
- Parce que keyof T peut contenir des number et des symbol, qu'un gabarit refuse ✓
- Pour forcer l'élargissement du littéral
- Pour éviter la distribution sur l'union des clés
- Parce que Capitalize exige une intersection
Pourquoi : `keyof T` est une union de `string | number | symbol`. Un littéral de gabarit et `Capitalize` n'acceptent pas un `symbol`, et la compilation échoue avec `TS2344`. L'intersection `string & K` ne garde que la partie utilisable, et c'est ce qu'on lit dans la plupart des bibliothèques : une correction de typage, pas une astuce.
Niveau senior