TypeScript Academy · Leçon

Conditionnelles au niveau des types

Effectuer des branchements sur les types avec des expressions de types conditionnels.

Conditionnelles au niveau des types 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.

La condition au niveau des types

Le langage des types gagne une capacité de branchement grâce aux types conditionnels. La syntaxe T extends U ? X : Y se lit ainsi : si T peut être utilisé là où U est attendu, le résultat est X, sinon c’est Y.

C’est l’équivalent au niveau des types d’une expression conditionnelle if / else.

type IsString<T> = T extends string ? "yes" : "no";

type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"

L’extension signifie la compatibilité d’affectation

La vérification ne porte pas sur l’égalité. T extends U est vrai lorsqu’une valeur de type T pourrait être utilisée là où un U est attendu. Les types littéraux sont compatibles avec leur type de base.

type T1 = "hello" extends string ? true : false; // true
type T2 = string extends "hello" ? true : false; // false
type T3 = 42 extends number ? true : false;       // true

Choisir un type de résultat

Les conditionnelles permettent à un générique de renvoyer des formes différentes selon l’entrée. Ici, l’opération d’enveloppement traite différemment les tableaux et les valeurs scalaires.

type Wrap<T> = T extends unknown[]
  ? { list: T }
  : { value: T };

type A = Wrap<number>;   // { value: number }
type B = Wrap<string[]>; // { list: string[] }

Filtrer vers aucun type

Une astuce courante consiste à renvoyer never dans une branche. never signifie « aucune valeur » et sert à supprimer ensuite des membres des unions.

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

type A = OnlyStrings<string>; // string
type B = OnlyStrings<number>; // never

Déduire avec une inférence

La véritable puissance apparaît avec le mot-clé infer. Dans une conditionnelle, infer introduit une nouvelle variable de type qui capture une partie du type correspondant.

Ici, nous capturons le type des éléments d’un tableau.

type ElementType<T> = T extends (infer U)[] ? U : never;

type A = ElementType<number[]>; // number
type B = ElementType<string[]>; // string

Déduire les résultats de fonctions

Vous pouvez placer infer n’importe où dans le motif. Pour extraire le type de retour d’une fonction, déduisez la partie située après la flèche. C’est ainsi que fonctionne l’utilitaire intégré ReturnType.

type MyReturn<T> = T extends (...args: any[]) => infer R ? R : never;

type A = MyReturn<() => number>;      // number
type B = MyReturn<(x: string) => boolean>; // boolean

Déduire plusieurs éléments

Une seule conditionnelle peut introduire plusieurs variables infer à la fois. Ici, nous récupérons le premier élément et le reste d’un tuple.

type FirstRest<T> = T extends [infer H, ...infer R]
  ? { head: H; rest: R }
  : never;

type A = FirstRest<[1, 2, 3]>;
// { head: 1; rest: [2, 3] }

Conditionnelles imbriquées

Les conditionnelles s’imbriquent comme des instructions conditionnelles enchaînées avec else if. La branche par défaut d’une conditionnelle peut elle-même être une autre conditionnelle, formant une échelle de décisions.

type Describe<T> =
  T extends string ? "text" :
  T extends number ? "num" :
  T extends boolean ? "flag" :
  "other";

type A = Describe<number>; // "num"
type B = Describe<null>;   // "other"

Les conditions comme garde-fous

Utilisez une conditionnelle pour vérifier une structure avant d’en extraire des éléments. Si l’entrée ne correspond pas, utilisez never comme solution de repli afin que l’utilisation incorrecte soit visible.

type GetName<T> = T extends { name: infer N } ? N : never;

type A = GetName<{ name: string }>; // string
type B = GetName<{ age: number }>;  // never

Combiner les conditions

Vous pouvez exiger plusieurs conditions en les imbriquant. Ici, un type doit être à la fois un objet et posséder un id pour être accepté.

type RequireId<T> =
  T extends object
    ? T extends { id: unknown } ? T : never
    : never;

type A = RequireId<{ id: 1; x: 2 }>; // { id: 1; x: 2 }
type B = RequireId<{ x: 2 }>;        // never

Les conditionnels sont partout

La plupart des types utilitaires intégrés sont en réalité des conditionnelles : NonNullable, Extract, Exclude, Parameters et ReturnType. Comprendre extends ? : les rend tous accessibles.

type MyNonNullable<T> = T extends null | undefined ? never : T;

type A = MyNonNullable<string | null>; // string

Vérification rapide

Vérifiez votre compréhension des types conditionnels et de l’inférence.

Récapitulatif

Les types conditionnels donnent au langage des types une structure conditionnelle et la reconnaissance de motifs.

T extends U ? X : Y effectue une branche selon la compatibilité d’affectation.
infer capture les parties correspondantes dans de nouvelles variables.
Les conditionnelles s’imbriquent pour former des échelles de décisions.
Renvoyer never filtre les membres.

Ensuite : réinjecter une conditionnelle dans elle-même pour obtenir la récursion.

Questions Fréquemment Posées

La leçon « Conditionnelles au niveau des types » est-elle gratuite ?

Oui — le texte complet de « Conditionnelles au niveau des types » 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 « Conditionnelles au niveau des types » ?

Effectuer des branchements sur les types avec des expressions de types conditionnels. 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 « Conditionnelles au niveau des types » ?

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