Formations — 1 037 leçons en français

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 » ?

  1. Il désactive la vérification de types sur la valeur et sur tout ce qui en dérive ✓
  2. Il accepte toutes les valeurs mais interdit les opérations non vérifiées
  3. Il convertit la valeur au type attendu à l'exécution
  4. 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 ?

  1. `never` ✓
  2. `void`
  3. `undefined`
  4. `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 » ?

  1. Un « any » est acceptable par n'importe quel type, un « unknown » ne l'est que par « unknown » et « any » ✓
  2. « unknown » n'accepte pas toutes les valeurs, « any » si
  3. « unknown » est vérifié à l'exécution, « any » non
  4. « 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 ?

  1. Il renvoie « any » : il faut le ramener à « unknown » puis valider ✓
  2. Il renvoie « unknown » : une garde est déjà imposée par le compilateur
  3. Il renvoie « object » : un accès de propriété suffit
  4. 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));
    }
  }
}
  1. TS2322 à la compilation : le membre non traité n'est pas affectable à « never » ✓
  2. Rien : l'exception sera levée à l'exécution
  3. TS2367 : la comparaison devient impossible
  4. 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

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