Le type never et les états impossibles
Modéliser le code inaccessible et les valeurs impossibles avec never.
Le type never et les états impossibles est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.
Le type never
never est le type vide : il représente des valeurs qui ne peuvent jamais apparaître. Aucune valeur ne peut être affectée à never (à l'exception de never lui-même). Il marque les situations qui devraient être impossibles.
// You cannot create a value of type never
function crash(): never {
throw new Error('boom');
}
try { crash(); } catch (e) { console.log('caught'); }Les fonctions qui ne renvoient jamais de valeur
Une fonction qui exécute toujours throw ne renvoie jamais de valeur normalement ; son type de retour est donc never. Cela indique aux appelants, ainsi qu'au compilateur, que l'exécution s'arrête ici.
function fail(message: string): never {
throw new Error(message);
}
try { fail('invalid'); } catch (e) { console.log('handled'); }Les boucles infinies renvoient never
Une fonction qui contient une boucle infinie ne renvoie elle non plus jamais de valeur ; elle est donc également typée never. Le compilateur reconnaît que le flux d'exécution ne peut pas continuer après cette fonction.
function listen(): never {
while (true) {
// forever
break; // (break added so the demo terminates)
}
throw new Error('stopped');
}
console.log('listen has return type never');never et void
Ne confondez pas never et void. Une fonction void renvoie une valeur (elle ne produit simplement aucune valeur utile). Une fonction never ne renvoie jamais de valeur : elle lève une erreur ou boucle indéfiniment.
function logIt(): void {
console.log('done'); // returns normally
}
function abort(): never {
throw new Error('stop'); // never returns
}
logIt();
try { abort(); } catch (e) { console.log('ok'); }never dans les vérifications d'exhaustivité
L'utilisation la plus pratique de never est la vérification d'exhaustivité. Dans la branche par défaut d'un switch, affectez la variable à un never. Si tous les cas sont traités, la variable est déjà de type never et la compilation réussit.
type Shape = 'circle' | 'square';
function area(s: Shape): string {
switch (s) {
case 'circle': return 'pi r^2';
case 'square': return 'a^2';
default:
const _check: never = s; // ok: all handled
return _check;
}
}
console.log(area('square'));Détecter les cas manquants
Si quelqu'un ajoute un nouveau membre à une union mais oublie un cas, la valeur restante n'est plus de type never, et l'affectation échoue lors de la compilation. La vérification avec never transforme une lacune silencieuse en erreur explicite.
type Shape = 'circle' | 'square' | 'triangle';
// If 'triangle' case is missing, assigning s to never
// would error: 'triangle' is not assignable to never.
console.log('Add a case for every member');never dans les branches d'union impossibles
Lorsque la réduction élimine toutes les possibilités, le type restant est never. Le compilateur sait que cette branche est inaccessible, ce qui peut révéler des erreurs de logique.
function check(x: string | number): void {
if (typeof x === 'string') {
console.log('string');
} else if (typeof x === 'number') {
console.log('number');
} else {
// x is never here
console.log('unreachable');
}
}
check('hi');never comme type inférieur
never est le type inférieur : il peut être affecté à tout autre type, car une valeur qui ne peut pas exister est, par vacuité, compatible avec n'importe quoi. C'est pourquoi un throw peut apparaître à n'importe quel endroit où une expression est attendue.
function getOrThrow(v: string | null): string {
return v ?? fail();
}
function fail(): never {
throw new Error('missing');
}
console.log(getOrThrow('value'));Filtrer les unions vers never
Dans les types conditionnels et mappés, never signifie « supprimer ceci ». Faire une union avec never ne change rien : T | never est simplement T. Cela en fait le choix naturel pour filtrer.
type Keep<T> = T extends string ? T : never;
type R = Keep<'a' | 1 | 'b'>; // 'a' | 'b'
const x: R = 'a';
console.log(x);Modéliser les états impossibles
Utilisez never dans les structures d'objets pour rendre les combinaisons illégales impossibles à représenter. Ici, un état « en chargement » ne peut pas également contenir de données, car le type l'interdit.
type State =
| { status: 'loading'; data?: never }
| { status: 'ready'; data: number };
const s: State = { status: 'ready', data: 7 };
console.log(s);never améliore la sûreté de la refactorisation
Comme les vérifications d'exhaustivité avec never échouent lorsqu'un cas manque, elles rendent la refactorisation plus sûre : étendez une union et le compilateur vous indique chaque endroit à mettre à jour.
type Cmd = 'start' | 'stop';
function run(c: Cmd): string {
if (c === 'start') return 'starting';
if (c === 'stop') return 'stopping';
const _x: never = c;
return _x;
}
console.log(run('start'));Vérification rapide
Évaluez votre compréhension du type never.
Récapitulatif : type vide
Vous avez appris que never :
- Est le type vide — aucune valeur ne peut appartenir à ce type.
- Est le type de retour des fonctions qui lèvent une exception ou bouclent indéfiniment.
- Permet les vérifications d'exhaustivité dans les valeurs par défaut de
switch. - Apparaît dans les branches de raffinement impossibles et filtre les unions dans la logique des types.
Ensuite, nous examinerons void et ce qui le distingue.
function assertNever(x: never): never {
throw new Error('Unexpected: ' + String(x));
}
console.log('assertNever guards exhaustiveness');Questions Fréquemment Posées
La leçon « Le type never et les états impossibles » est-elle gratuite ?
Oui — le texte complet de « Le type never et les états impossibles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Le type never et les états impossibles » ?
Modéliser le code inaccessible et les valeurs impossibles avec never. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer TypeScript Academy ?
Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Le type never et les états impossibles » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?
Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Comprendre unknown et any
- Le type never et les états impossibles
- Le type void dans les fonctions
- Manipuler unknown avec la sécurité du typage