TypeScript Academy · Leçon

Types conditionnels distributifs

Contrôler la distribution des conditionnelles sur les unions.

Types conditionnels distributifs est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Un comportement surprenant

Les types conditionnels obéissent à une règle particulière : lorsque le type vérifié est un paramètre de type nu et que vous fournissez une union, la conditionnelle se distribue sur chaque membre séparément, puis réunit les résultats en une union.

C’est le fondement de Exclude, Extract et de nombreux utilitaires.

type ToArray<T> = T extends unknown ? T[] : never;

type A = ToArray<string | number>;
// string[] | number[]  (NOT (string | number)[])

Ce que signifie « nu »

« Nu » signifie que le paramètre de type apparaît à lui seul à gauche de extends, sans être enveloppé dans un autre type. La distribution ne se produit qu’avec des paramètres nus.

type Naked<T> = T extends string ? "y" : "n";
// T is naked -> distributes over unions

Distribution étape par étape

Pour ToArray<string | number>, le compilateur évalue chaque membre :

ToArray<string> = string[]
ToArray<number> = number[]

Puis il les réunit en une union : string[] | number[].

type R = ToArray<boolean>;
// boolean is true | false, so:
// true[] | false[]

Filtrer une union

La distribution simplifie le filtrage. Associez les membres indésirables à never ; never disparaît d’une union, qui ne conserve alors que les membres retenus.

type Strings<T> = T extends string ? T : never;

type A = Strings<string | number | boolean>; // string

Le type sans valeur disparaît dans les unions

Un fait essentiel : X | never se simplifie en X. Ainsi, lorsqu’une branche distribuée produit never, ce membre est effectivement supprimé de l’union finale.

type A = string | never;        // string
type B = "a" | never | "b";     // "a" | "b"

Désactiver la distribution

Parfois, vous ne voulez pas de distribution, par exemple lorsque vous comparez une union entière comme une seule unité. Encadrez les deux côtés dans un tuple à un élément : [T] extends [U]. Désormais, T n’est plus nu et la distribution est désactivée.

type IsNever<T> = [T] extends [never] ? true : false;

type A = IsNever<never>;  // true
type B = IsNever<string>; // false

Pourquoi l’encapsulation fonctionne

En plaçant [T] à gauche, le type vérifié est un tuple, et non le paramètre seul. La règle spéciale de distribution ne s’applique plus, de sorte que l’union est vérifiée dans son ensemble.

type AllStrings<T> = [T] extends [string] ? true : false;

type A = AllStrings<"a" | "b">;     // true
type B = AllStrings<"a" | number>;  // false

Distribué ou non distribué

Comparez directement les deux formes. La version nue vérifie chaque membre ; la version enveloppée vérifie l’union comme un seul type.

type Distributed<T> = T extends string ? true : false;
type Wrapped<T> = [T] extends [string] ? true : false;

type A = Distributed<string | number>; // boolean (true | false)
type B = Wrapped<string | number>;     // false

Fonctionnement interne de l’exclusion

L’utilitaire intégré Exclude<T, U> retire de T tout membre compatible avec U. Il s’agit simplement d’une conditionnelle distributive qui associe never aux membres correspondants.

type MyExclude<T, U> = T extends U ? never : T;

type A = MyExclude<"a" | "b" | "c", "b">; // "a" | "c"

Fonctionnement interne de l’extraction

Extract<T, U> est l’image miroir : il ne conserve que les membres compatibles avec U. Même distribution, branches opposées.

type MyExtract<T, U> = T extends U ? T : never;

type A = MyExtract<"a" | "b" | "c", "a" | "c">; // "a" | "c"

Puissance pratique

La distribution vous permet de transformer chaque membre d’une union dans une seule expression : créer des tableaux pour chacun, ajouter un préfixe à chaque chaîne ou filtrer selon une structure. Combinée à [T] extends [U] pour vérifier l’union entière, elle vous permet de contrôler exactement le moment où la distribution s’applique.

Notation : Dans TypeScript, les types littéraux de modèle s’écrivent avec des chaînes délimitées par des accents graves contenant des emplacements dollar-accolade. Dans ces extraits, nous représentons ce motif par Tpl<...>, en listant chaque partie dans l’ordre ; par exemple, un modèle entre accents graves correspondant au préfixe littéral puis à Rest apparaît sous la forme Tpl<'prefix', infer Rest>.

type Prefix<T extends string> = T extends unknown ? Tpl<'id_', T> : never;
// Tpl<'id_', T> is the template literal type joining 'id_' with each T

type A = Prefix<'a' | 'b'>; // 'id_a' | 'id_b'

Vérification rapide

Vérifiez votre compréhension des conditionnelles distributives.

Récapitulatif

Les types conditionnels distributifs sont le moteur des utilitaires pour les unions.

Une conditionnelle nue T extends U ? se distribue sur chaque membre de l’union.
Les branches qui renvoient never filtrent les membres.
[T] extends [U] désactive la distribution pour vérifier une union entière.
Exclude et Extract sont de petites conditionnelles distributives.

Prochain cours 22 : l’arithmétique dans le système de types.

Questions Fréquemment Posées

La leçon « Types conditionnels distributifs » est-elle gratuite ?

Oui — le texte complet de « Types conditionnels distributifs » 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 « Types conditionnels distributifs » ?

Contrôler la distribution des conditionnelles sur les unions. 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 4 sur 4.

Combien de temps prend la leçon « Types conditionnels distributifs » ?

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

← Retour à TypeScript Academy