Mønstre for dypt nestet typeutledning
Bruk infer rekursivt for å trekke ut komplekse typer.
Mønstre for dypt nestet typeutledning er en gratis leksjon i TypeScript Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i TypeScript Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.
Hvorfor dyp inferens?
Noen ganger ligger typen du trenger, skjult inne i flere lag med generiske typer. Dyp inferens bruker rekursive eller kjedede betingede typer for å nå frem til den.
type DeepUnwrap<T> =
T extends Promise<infer U>
? DeepUnwrap<U>
: T;
type A = DeepUnwrap<Promise<Promise<string>>>; // stringRekursive betingede typer
TypeScript 4.1+ støtter rekursive betingede typer, slik at du kan fjerne omslagslag ett av gangen.
type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;
type B = Flatten<string[][][]>; // stringInferens fra nøstede generiske typer
Du kan kjede flere infer-variabler i én extends-del for å hente ut flere lag samtidig.
type InnerValue<T> =
T extends Map<any, infer V>
? V extends Set<infer S>
? S
: V
: T;
type C = InnerValue<Map<string, Set<number>>>; // numberTyper for dypt nestede objektegenskaper
Rekursive typer kan gå gjennom objektstrukturer for å hente ut typer for dypt nestede egenskaper.
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 } }Dyp uthenting av array-elementtyper
Ved å kombinere rekursiv utpakking med array-håndtering kan du håndtere vilkårlig dybde av nøsting.
type ElementType<T> = T extends (infer U)[] ? ElementType<U> : T;
type D = ElementType<number[][][]>; // numberHaleresursjon for tupler
Haleresursiv manipulering av tupler er et vanlig mønster for typesikre pipelines og typer for funksjonssammensetning.
type Last<T extends any[]> =
T extends [...infer _, infer L] ? L : never;
type E = Last<[1, 2, 3]>; // 3Dybdebegrensninger og praktiske hensyn
TypeScript begrenser rekursjonsdybden for å hindre uendelige løkker. Hold rekursjonen grunn og vurder å sette en grense med en dybdemåler ved behov.
// Deep recursion may hit "Type instantiation is excessively deep"
// Simplify or use branded types to break deep chainsInfer i unionsdistribusjon
Når T er en union, distribueres betingede typer: hvert medlem matches separat, og resultatene slås sammen til en union.
type Unwrap<T> = T extends Promise<infer U> ? U : T;
type F = Unwrap<Promise<string> | Promise<number> | boolean>;
// string | number | booleanInferens av rest-tupler
Mønstre for rest-tupler med infer muliggjør oppdeling i hode og hale samt variadisk typemanipulering.
type Init<T extends any[]> =
T extends [...infer I, any] ? I : never;
type G = Init<[1, 2, 3, 4]>; // [1, 2, 3]Praktisk eksempel: Nøstet API-respons
En nøstet API-responstype kan pakkes ut til datatypen sin ved hjelp av kjedet infer.
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[] }Oppsummering: Dyp inferens
Dyp inferens kombinerer rekursive betingede typer, flere infer-variabler og strukturell mønstergjenkjenning for å hente ut typer fra generiske strukturer med vilkårlig nøstingsdybde.
Hurtigsjekk
Hva returnerer Flatten<string[][]> hvis Flatten<T> = T extends Array<infer U> ? Flatten<U> : T?
Dette har du lært
Dyp inferens bruker rekursive betingede typer og kjedede infer-mønstre for å nå typer som ligger skjult inne i flere generiske omslag. Begrens rekursjonen for å unngå TypeScript sine dybdebegrensninger.
Lær deg TypeScript med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 101
- Leksjoner
- 352
Ofte stilte spørsmål
Er leksjonen «Mønstre for dypt nestet typeutledning» gratis?
Ja – hele teksten i «Mønstre for dypt nestet typeutledning» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av TypeScript Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Mønstre for dypt nestet typeutledning»?
Bruk infer rekursivt for å trekke ut komplekse typer. Du øver på TypeScript Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med TypeScript Academy?
Ingen tidligere erfaring er nødvendig. TypeScript Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.
Hvor lang tid tar leksjonen «Mønstre for dypt nestet typeutledning»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne TypeScript Academy-leksjonen?
Ja. Alle TypeScript Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Forstå infer i betingede typer
- Bygge ReturnType og Parameters fra bunnen av
- Mønstre for dypt nestet typeutledning
- Praktiske bruksområder for infer: pakke ut Promise-typer