Verschachtelte Inferenzmuster
Setzen Sie infer rekursiv zur Extraktion komplexer Typen ein.
Verschachtelte Inferenzmuster ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum tiefes Inferieren?
Manchmal ist der gewünschte Typ in mehreren Ebenen von Generics verborgen. Beim tiefen Inferieren werden rekursive oder verkettete bedingte Typen verwendet, um ihn zu erreichen.
type DeepUnwrap<T> =
T extends Promise<infer U>
? DeepUnwrap<U>
: T;
type A = DeepUnwrap<Promise<Promise<string>>>; // stringRekursive bedingte Typen
TypeScript 4.1+ unterstützt rekursive bedingte Typen, mit denen Sie Wrapper-Ebenen eine nach der anderen entfernen können.
type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;
type B = Flatten<string[][][]>; // stringInferieren aus verschachtelten Generics
Sie können mehrere infer-Variablen in einer einzigen extends-Klausel verketten, um mehrere Ebenen gleichzeitig zu erfassen.
type InnerValue<T> =
T extends Map<any, infer V>
? V extends Set<infer S>
? S
: V
: T;
type C = InnerValue<Map<string, Set<number>>>; // numberTypen tief verschachtelter Objekteigenschaften
Rekursive Typen können Objektstrukturen durchlaufen, um tief verschachtelte Eigenschaftstypen zu extrahieren.
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 } }Tiefes Extrahieren von Array-Elementtypen
Die Kombination aus rekursivem Auspacken und der Verarbeitung von Arrays deckt beliebige Verschachtelungstiefen ab.
type ElementType<T> = T extends (infer U)[] ? ElementType<U> : T;
type D = ElementType<number[][][]>; // numberRekursion am Tupelende
Die Manipulation von Tupeln mit Endrekursion ist ein gängiges Muster für typsichere Pipelines und Typen zur Funktionskomposition.
type Last<T extends any[]> =
T extends [...infer _, infer L] ? L : never;
type E = Last<[1, 2, 3]>; // 3Tiefenbegrenzungen und praktische Überlegungen
TypeScript begrenzt die Rekursionstiefe, um Endlosschleifen zu verhindern. Halten Sie die Rekursion flach und ziehen Sie bei Bedarf eine Begrenzung mithilfe eines Tiefenzählers in Betracht.
// Deep recursion may hit "Type instantiation is excessively deep"
// Simplify or use branded types to break deep chainsInferieren bei der Verteilung über Unions
Wenn T eine Union ist, werden bedingte Typen verteilt: Jedes Mitglied wird separat abgeglichen und die Ergebnisse zu einer Union zusammengeführt.
type Unwrap<T> = T extends Promise<infer U> ? U : T;
type F = Unwrap<Promise<string> | Promise<number> | boolean>;
// string | number | booleanInferieren von Rest-Tupeln
Rest-Tupel-Muster mit infer ermöglichen die Zerlegung in Kopf und Ende sowie die Manipulation variadischer Typen.
type Init<T extends any[]> =
T extends [...infer I, any] ? I : never;
type G = Init<[1, 2, 3, 4]>; // [1, 2, 3]Praxisbeispiel: Verschachtelte API-Antwort
Der Datentyp einer verschachtelten API-Antwort kann mithilfe von verkettetem infer auf den Datentyp reduziert werden.
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[] }Zusammenfassung: Tiefes Inferieren
Tiefes Inferieren kombiniert rekursive bedingte Typen, mehrere infer-Variablen und strukturellen Mustervergleich, um Typen aus beliebig tief verschachtelten generischen Strukturen zu extrahieren.
Kurzer Test
Was gibt Flatten zurück, wenn Flatten gilt?
Das haben Sie gelernt
Beim Inferieren tief verschachtelter Typen werden rekursive bedingte Typen und verkettete infer-Muster verwendet, um Typen zu erreichen, die in mehreren generischen Wrappern verborgen sind. Begrenzen Sie die Rekursion, um die Tiefenbegrenzungen von TypeScript einzuhalten.
Häufig gestellte Fragen
Ist die Lektion „Verschachtelte Inferenzmuster“ kostenlos?
Ja — der vollständige Text von „Verschachtelte Inferenzmuster“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Verschachtelte Inferenzmuster“?
Setzen Sie infer rekursiv zur Extraktion komplexer Typen ein. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um TypeScript Academy zu starten?
Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Verschachtelte Inferenzmuster“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?
Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- infer in bedingten Typen verstehen
- ReturnType und Parameters von Grund auf erstellen
- Verschachtelte Inferenzmuster
- Praxisnahe infer-Anwendungsfälle: Promises entpacken