Accueil › TypeScript › any, unknown, never
any, unknown, never — entretien TypeScript
5 questions posées en entretien, avec la bonne réponse et son explication.
Que fait exactement le type « any » ?
- Il désactive la vérification de types sur la valeur et sur tout ce qui en dérive ✓
- Il accepte toutes les valeurs mais interdit les opérations non vérifiées
- Il convertit la valeur au type attendu à l'exécution
- Il déclenche un avertissement à chaque usage
Pourquoi : « any » n'est pas un type souple, c'est l'absence de type : la valeur accepte tout, est acceptée partout, et chaque expression qui la touche devient « any » à son tour. Une seule annotation « any » à une frontière éteint le contrôle sur toute la chaîne qui en descend. La réponse qui décrit l'acceptation sans opérations correspond à « unknown » : c'est la confusion la plus fréquente en entretien.
Niveau junior
Quel est le type d'une fonction qui lève toujours une exception ?
- `never` ✓
- `void`
- `undefined`
- `unknown`
Pourquoi : « never » est le type sans aucune valeur : il annote ce qui ne rend jamais la main, par un « throw » ou une boucle infinie. « void » décrirait une fonction qui revient sans valeur utile — ce n'est pas le cas. La distinction est utile au compilateur : après un appel à une fonction « never », le code suivant est reconnu inatteignable et l'affinage de type en tient compte.
Niveau junior
Quelle est la différence décisive entre « any » et « unknown » ?
- Un « any » est acceptable par n'importe quel type, un « unknown » ne l'est que par « unknown » et « any » ✓
- « unknown » n'accepte pas toutes les valeurs, « any » si
- « unknown » est vérifié à l'exécution, « any » non
- « unknown » est un alias de « any » introduit pour la lisibilité
Pourquoi : Les deux acceptent tout en entrée : la sûreté se joue dans l'autre sens. Comme « unknown » n'est acceptable par presque rien, le compilateur réclame une réduction — « typeof », « Array.isArray », une garde « v is T » — avant tout usage. La vérification est reportée, pas abandonnée. Rien n'est contrôlé à l'exécution dans les deux cas : seul le code de garde que vous écrivez l'est.
Niveau confirme
Que renvoie « JSON.parse » et quelle discipline cela impose-t-il ?
- Il renvoie « any » : il faut le ramener à « unknown » puis valider ✓
- Il renvoie « unknown » : une garde est déjà imposée par le compilateur
- Il renvoie « object » : un accès de propriété suffit
- Il renvoie le type attendu si la variable est annotée
Pourquoi : La signature de « JSON.parse » date d'avant « unknown » et renvoie « any » : le résultat traverse donc toutes les annotations sans un mot, y compris une annotation fausse. Écrire « const brut: unknown = JSON.parse(texte) » rétablit l'obligation de vérifier. C'est le point de départ de toute validation de frontière, et la réponse attendue dès qu'un entretien parle de données externes.
Niveau confirme
Que se passe-t-il si on ajoute un membre à l'union sans toucher au « switch » ?
type E = { t: "clic" } | { t: "touche" };
function f(e: E): string {
switch (e.t) {
case "clic": return "clic";
case "touche": return "touche";
default: {
const jamais: never = e;
throw new Error(String(jamais));
}
}
}
- TS2322 à la compilation : le membre non traité n'est pas affectable à « never » ✓
- Rien : l'exception sera levée à l'exécution
- TS2367 : la comparaison devient impossible
- Rien, mais la fonction renvoie « undefined » pour ce membre
Pourquoi : Dans le « default », le type résiduel vaut ce qui n'a pas été traité. Tout étant couvert, c'est « never » et l'affectation passe ; dès qu'un membre est ajouté, le résiduel est ce membre et TS2322 désigne l'aiguillage incomplet. C'est une preuve à la compilation, pas un garde-fou à l'exécution — le « throw » ne sert que si une valeur hors union franchit une frontière non validée.
Niveau senior