0Pricing
TypeScript Academy · Leçon

Types conditionnels distributifs

Comprenez comment les conditions se distribuent sur les membres d’une union

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.

Bienvenue

Les types conditionnels distributifs appliquent séparément un type conditionnel à chaque membre d’une union. Ce comportement puissant permet de transformer et de filtrer les unions.

Qu’est-ce que la distribution

Lorsqu’un type conditionnel possède un T générique utilisé seul et que T est une union, TypeScript applique séparément la condition à chaque membre de l’union.
type Wrap<T> = T extends any ? { value: T } : never;
type R = Wrap<string | number>;
// = { value: string } | { value: number }

La condition essentielle

La distribution ne se produit que lorsque T est un paramètre de type générique utilisé seul (et non encapsulé). Entourer T d’un tuple l’empêche.
type Bare<T> = T extends string ? 'yes' : 'no';
type Wrapped<T> = [T] extends [string] ? 'yes' : 'no';
type B = Bare<'a' | 'b'>; // 'yes' | 'yes' = 'yes'
type W = Wrapped<'a' | 'b'>; // 'no' — treated as a tuple

Filtrer les unions avec never

Renvoyer never depuis la branche false filtre les membres de l’union.
type StringsOnly<T> = T extends string ? T : never;
type S = StringsOnly<string | number | boolean>; // string

Utilitaire intégré Extract

Extract est implémenté avec un type conditionnel distributif qui conserve les membres pouvant être affectés à U.
type Extract<T, U> = T extends U ? T : never;
type E = Extract<string | number | boolean, string | number>; // string | number

Utilitaire intégré Exclude

Exclude supprime les membres de l’union pouvant être affectés à U.
type Exclude<T, U> = T extends U ? never : T;
type Ex = Exclude<string | number | boolean, boolean>; // string | number

Distribution de ToArray

Appliquez ToArray séparément à chaque membre de l’union grâce à la distribution.
type ToArray<T> = T extends any ? T[] : never;
type R = ToArray<string | number>; // string[] | number[]

Cas d’utilisation pour empêcher la distribution

Vous pouvez parfois vouloir traiter l’union entière comme un seul argument de type, sans la distribuer.
type IsUnion<T> = [T] extends [T] ? [T] extends [Exclude<T, T>] ? false : true : false;

Types mappés distributifs

Combinez les types conditionnels distributifs avec les types mappés pour transformer des propriétés de manière sélective.
type PickByValue<T, V> = {
  [K in keyof T as T[K] extends V ? K : never]: T[K]
};

Type conditionnel distributif dans ReturnType

Le comportement distributif permet à ReturnType de fonctionner correctement lorsque T est une union de types de fonctions.
type Fn = (() => string) | (() => number);
type R = ReturnType<Fn>; // string | number

Distribution immédiate ou différée

TypeScript diffère l’évaluation des types conditionnels comportant des paramètres de type libres jusqu’à leur résolution : c’est l’évaluation différée.

Vérification rapide

Que vaut `type R = (string | number) extends string ? 'yes' : 'no'` lorsque T n’est PAS un générique utilisé seul ?

Récapitulatif

Les types conditionnels distributifs s’appliquent séparément à chaque membre d’une union lorsque T est un paramètre générique utilisé seul. Cela permet à Extract, Exclude et aux filtres d’union personnalisés de fonctionner. Encapsulez T dans un tuple pour empêcher la distribution.

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

Comprenez comment les conditions se distribuent sur les membres d’une union 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

  1. keyof et types d’accès indexé
  2. Contraintes génériques : affiner les paramètres de types
  3. Types conditionnels : T extends U ? X : Y
  4. Types conditionnels distributifs
← Retour à TypeScript Academy