Motifs de déduction profondément imbriqués
Appliquez infer récursivement pour extraire des types complexes
Motifs de déduction profondément imbriqués est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Pourquoi une inférence approfondie ?
Parfois, le type recherché est enfoui sous plusieurs couches de génériques. L’inférence approfondie utilise des types conditionnels récursifs ou chaînés pour l’atteindre.
type DeepUnwrap<T> =
T extends Promise<infer U>
? DeepUnwrap<U>
: T;
type A = DeepUnwrap<Promise<Promise<string>>>; // stringTypes conditionnels récursifs
TypeScript 4.1 et les versions ultérieures prennent en charge les types conditionnels récursifs, ce qui permet de retirer les couches d’enveloppe une par une.
type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;
type B = Flatten<string[][][]>; // stringInférence à partir de génériques imbriqués
Vous pouvez enchaîner plusieurs variables d’inférence dans une même clause extends pour capturer plusieurs couches à la fois.
type InnerValue<T> =
T extends Map<any, infer V>
? V extends Set<infer S>
? S
: V
: T;
type C = InnerValue<Map<string, Set<number>>>; // numberTypes de propriétés d’objets imbriqués
Les types récursifs peuvent parcourir les formes d’objets pour extraire les types de propriétés profondément imbriquées.
type DeepGet<T, K extends keyof T> =
T[K] extends object ? T[K] : never;
type Nested = { user: { profile: { name: string } } };
type Profile = DeepGet<Nested, "user">; // { profile: { name: string } }Extraction approfondie des types d’éléments de tableaux
La combinaison du retrait récursif des enveloppes et de la gestion des tableaux prend en charge toute profondeur d’imbrication.
type ElementType<T> = T extends (infer U)[] ? ElementType<U> : T;
type D = ElementType<number[][][]>; // numberRécursion terminale sur les tuples
La manipulation récursive terminale des tuples est un modèle courant pour les pipelines sûrs du point de vue des types et les types de composition de fonctions.
type Last<T extends any[]> =
T extends [...infer _, infer L] ? L : never;
type E = Last<[1, 2, 3]>; // 3Limites de profondeur et considérations pratiques
TypeScript limite la profondeur de récursion pour empêcher les boucles infinies. Gardez la récursion peu profonde et envisagez de la plafonner avec un compteur de profondeur lorsque cela est nécessaire.
// Deep recursion may hit "Type instantiation is excessively deep"
// Simplify or use branded types to break deep chainsInférence dans la distribution des unions
Lorsque T est une union, les types conditionnels sont distribués : chaque membre est comparé séparément et les résultats sont réunis dans une union.
type Unwrap<T> = T extends Promise<infer U> ? U : T;
type F = Unwrap<Promise<string> | Promise<number> | boolean>;
// string | number | booleanInférence de tuples avec reste
Les modèles de tuples avec reste et infer permettent de décomposer la tête et la fin d’un tuple et de manipuler des types variadiques.
type Init<T extends any[]> =
T extends [...infer I, any] ? I : never;
type G = Init<[1, 2, 3, 4]>; // [1, 2, 3]Exemple concret : réponse d’API imbriquée
Le type d’une réponse d’API imbriquée peut être débarrassé de ses enveloppes jusqu’à son type de données à l’aide d’inférences enchaînées.
type ApiResponse<T> = { data: T; status: number };
type UnwrapApi<T> = T extends ApiResponse<infer D> ? D : T;
type H = UnwrapApi<ApiResponse<{ users: string[] }>>; // { users: string[] }Récapitulatif : inférence approfondie
L’inférence approfondie combine des types conditionnels récursifs, plusieurs variables d’inférence et la correspondance de modèles structurels pour extraire des types de structures génériques imbriquées à une profondeur quelconque.
Vérification rapide
Que renvoie Flatten si Flatten ?
Ce que vous avez appris
L’inférence profondément imbriquée utilise des types conditionnels récursifs et des modèles d’inférence enchaînés pour atteindre les types enfouis dans plusieurs enveloppes génériques. Limitez la récursion pour éviter les limites de profondeur de TypeScript.
Questions Fréquemment Posées
La leçon « Motifs de déduction profondément imbriqués » est-elle gratuite ?
Oui — le texte complet de « Motifs de déduction profondément imbriqués » 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 « Motifs de déduction profondément imbriqués » ?
Appliquez infer récursivement pour extraire des types complexes 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 3 sur 4.
Combien de temps prend la leçon « Motifs de déduction profondément imbriqués » ?
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 infer dans les types conditionnels
- Créer ReturnType et Parameters à partir de zéro
- Motifs de déduction profondément imbriqués
- Cas pratiques d’utilisation de infer : déballer les promesses