TypeScript - Never: Comprendre le Type de Bas

Bonjour, aspirants programmeurs ! Aujourd'hui, nous allons plonger dans l'un des types plus énigmatiques de TypeScript : le type never. Ne vous inquiétez pas si vous êtes nouveau dans la programmation - je vais vous guider pas à pas à travers ce concept, tout comme j'ai fait pour des centaines d'étudiants au fil des ans. Alors, prenez votre boisson favorite et mettons-nous en route pour cette aventure passionnante dans le monde de TypeScript !

TypeScript - Never

Qu'est-ce que le type never ?

Le type never en TypeScript est souvent appelé le "type de bas" ou le "type vide". Il représente un type qui ne devrait jamais se produire. Maintenant, vous pourriez penser : "Pourquoi aurions-nous besoin d'un type qui ne se produit jamais ?" Eh bien, mes curieux amis, c'est plus utile que vous ne pourriez le penser !

Quand utiliser never ?

Pour représenter des scénarios impossibles
Pour gérer des vérifications exhaustives
Dans des fonctions qui ne retournent jamais

Voyons quelques exemples pour clarifier ces concepts.

Exemple 1 : Représenter des Scénarios Impossibles

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

let result = throwError("Oops! Something went wrong!");
console.log(result); // Cette ligne ne sera jamais atteinte

Dans cet exemple, la fonction throwError est garantie de lancer une erreur et de ne jamais retourner normalement. Par conséquent, son type de retour est never.

Pensez-y comme ça : si vous cuisinez un gâteau et que la recette dit "cuisiner jusqu'à jamais", vous savez que ce gâteau ne sortira jamais du four !

Exemple 2 : Vérifications Exhaustives

type Shape = "circle" | "square" | "triangle";

function getArea(shape: Shape): number {
switch (shape) {
case "circle":
return Math.PI * Math.pow(5, 2);
case "square":
return 10 * 10;
case "triangle":
return (10 * 5) / 2;
default:
const _exhaustiveCheck: never = shape;
return _exhaustiveCheck;
}
}

Ici, never nous aide à nous assurer que nous avons couvert toutes les formes possibles. Si nous ajoutons une nouvelle forme au type Shape mais oublions d'ajouter un cas pour elle dans getArea, TypeScript nous donnera une erreur. C'est comme avoir un assistant utile qui vous rappelle lorsque vous avez oublié quelque chose !

Exemple 3 : Fonctions Qui Ne Retournent Jamais

function infiniteLoop(): never {
while (true) {
console.log("This loop never ends!");
}
}

Cette fonction va tourner pour toujours (ou jusqu'à ce que votre ordinateur se mette en panne de mémoire). Puisqu'elle ne se termine jamais, son type de retour est never. C'est comme dire à votre ami que vous arrêterez de parler "jamais" - ils savent qu'ils sont en pour une longue conversation !

Le type never vs. void

Maintenant, vous pourriez vous demander : "Comment never est-il différent de void?" Excellent pregunta ! Reprenons.

void

Le type void est utilisé lorsque une fonction ne retourne aucune valeur, mais qu'elle termine son exécution.

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

logMessage("Hello, TypeScript!"); // Cette fonction retourne undefined

never

Le type never, d'autre part, est utilisé lorsque une fonction ne termine jamais son exécution ou jette toujours une erreur.

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

failwithError("This function never returns!");

Pensez-y comme ça : void est comme aller dans un magasin et revenir les mains vides, tandis que never est comme partir en voyage sans destination - vous ne revenez jamais !

Utilisations Pratiques de never

Voyons quelques exemples supplémentaires où never peut être utile.

Exemple 4 : Guards de Type

type Square = { kind: "square", size: number };
type Circle = { kind: "circle", radius: number };
type Shape = Square | Circle;

function assertNever(x: never): never {
throw new Error("Unexpected object: " + x);
}

function getArea(shape: Shape) {
switch (shape.kind) {
case "square": return shape.size * shape.size;
case "circle": return Math.PI * shape.radius ** 2;
default: return assertNever(shape); // Erreur si shape n'est ni Square ni Circle
}
}

Dans cet exemple, assertNever nous aide à attraper tout cas que nous pourrions avoir manqué. C'est comme avoir un filet de sécurité lorsque vous apprenez à jongler avec les types !

Exemple 5 : Détection de Code Inatteignable

function neverReaches(): never {
while (true) {
// Certaines opérations
}
console.log("This line will never be reached");  // Erreur TypeScript
}

TypeScript est suffisamment intelligent pour savoir que l'instruction console.log ne sera jamais atteinte, et il vous donnera une erreur. C'est comme avoir un GPS qui vous dit lorsque vous essayez de conduire à un endroit qui n'existe pas !

Méthodes et Propriétés de never

Vous pourriez maintenant vous demander si never a des méthodes ou des propriétés. La vérité est, never n'a aucunes de ses propres méthodes ou propriétés car il représente un type qui ne devrait jamais se produire. Cependant, c'est toujours une partie importante du système de types de TypeScript.

Voici un tableau résumant ce que vous pouvez (ou ne pouvez pas) faire avec never :

Opération	Résultat	Explication
Assigner à `never`	✅ Autorisé	Tout type peut être assigné à `never`
Assigner `never` à d'autres types	❌ Non Autorisé	`never` ne peut pas être assigné à tout autre type
Appeler des méthodes sur `never`	❌ Non Autorisé	Puisque `never` ne devrait jamais se produire, vous ne pouvez pas appeler de méthodes sur lui
Utiliser `never` dans des unions	✅ Autorisé mais a aucun effet	`never` est ignoré dans les types unions
Utiliser `never` dans des intersections	✅ Autorisé et résulte en `never`	Tout type intersecté avec `never` résulte en `never`

Conclusion

Et voilà, mes chers étudiants ! Nous avons traversé le pays du never, explorant ses recoins et ses coins. Souvenez-vous, never est comme ce ami qui annule toujours les plans - ils ne montrent jamais, mais ils sont toujours importants à garder à l'esprit !

Comprendre never peut sembler difficile au début, mais avec de la pratique, vous trouverez qu'il est un outil précieux dans votre boîte à outils TypeScript. Il aide à rendre votre code plus robuste, à attraper des erreurs potentiels, et même à vous faire réfléchir plus profondément au comportement de vos fonctions.

Continuez à coder, continuez à apprendre, et n'oubliez jamais d'essayer de nouvelles choses en TypeScript ! Jusqu'à la prochaine fois, que vos erreurs de compilation soient rares et que vos inférences de type soient fortes !

Credits: Image by storyset