Le type never est très rarement utilisé dans les scripts, seulement quand la fonction ne va jamais atteindre une déclaration de retour.

un bus avec never stress écrit dessus

Ce qui arrive le plus souvent pour deux raisons :

  • la fonction jette une erreur
  • la fonction boucle à l'infini

Voyons un exemple du cas d'utilisation le plus courant - la fonction lance une erreur et n'atteint donc jamais une déclaration de retour :

function throwError(message: string): never {
  throw new Error(message);
}

Il ne faut pas confondre avec void

function logger(message: string): void {
  console.log(message);
}

La différence est que void est utilisé pour une fonction qui ne renvoie rien, techniquement elle peut renvoyer null ou undefined. Si nous retournons accidentellement quelque chose à partir d'une fonction qui renvoie void, nous recevons un message d'erreur.

Avec le type never, cependant, une fonction ne renverra jamais rien. Nous l'annotons donc avec never pour dire que nous n'atteindrons jamais la fin de cette fonction. Nous n'allons jamais exécuter la fonction complètement.

Il est très rare que nous ayons des fonctions qui doivent être typées avec never comme valeur de retour. Par exemple, si nous ne lançons une erreur que de temps en temps, nous ne devons pas annoter la fonction avec never 

function sometimesThrowError(message: string): number {
  if (!message) {
    throw new Error(message);
  }

  return 42;
}

Dans le scénario ci-dessus, nous devrions toujours annoter la fonction comme renvoyant un nombre et non jamais car il existe un scénario dans lequel la fonction atteint sa fin et revient.

Nous n'annotons une fonction avec le type never que si elle n'atteint jamais sa fin. Si elle ne fait que lancer une erreur, nous ne l'annotons pas avec never.

Quand

Bien que never soit rarement utilisé explicitement, vous le rencontrerez souvent dans les messages d'erreur TypeScript. Cela arrive quand TypeScript détermine qu'une situation est impossible ou dangereuse.

Exemple concret : Accès dynamique aux propriétés

Regardons ce code qui semble correct mais génère une erreur never :

interface FormData {
  name: string;
  age: number;
  hobbies: string[];
}

const formValues: FormData = { name: "John", age: 30, hobbies: ["reading"] };
const defaultValues: FormData = { name: "", age: 0, hobbies: [] };
const clearableFields: (keyof FormData)[] = ["name", "age"];

// ❌ Erreur : Type 'string' is not assignable to type 'never'
clearableFields.forEach((field) => {
  if (defaultValues[field]) {
    formValues[field] = defaultValues[field]; // ERREUR ICI
  }
});

Pourquoi cette erreur ?

TypeScript raisonne ainsi :

field peut être "name" | "age" | "hobbies"

formValues[field] peut donc être string | number | string[]

defaultValues[field] peut aussi être string | number | string[]

TypeScript ne peut pas garantir que ces deux valeurs auront le même type :

  • Et si formValues["name"] (string) recevait defaultValues["age"] (number) ?

Pour se protéger contre cette incohérence potentielle, TypeScript utilise le type never pour dire "cette assignation est impossible à valider".

Solution : Éviter l'assignation directe

// ✅ Solution qui fonctionne
clearableFields.forEach((field) => {
  const currentValues = { ...formValues };
  const resetValues: Record<string, string | number | string[]> = {};
  
  if (defaultValues[field] !== undefined) {
    resetValues[field] = defaultValues[field];
  }
  
  // Fusionner les objets au lieu d'assigner directement
  const newFormValues = { ...currentValues, ...resetValues };
});

Résumé

  • never représente quelque chose qui ne peut jamais arriver
  • Utilisé explicitement pour les fonctions qui ne se terminent jamais
  • Apparaît souvent dans les erreurs quand TypeScript détecte une situation impossible.