Rekursjonsdybde og begrensninger
Forstå begrensningene for rekursjonsdybde i TypeScript.
Rekursjonsdybde og begrensninger er en gratis leksjon i TypeScript Academy på CoddyKit. Dette er leksjon 4 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.
TypeScript har rekursjonsgrenser
Rekursive typer er kraftige, men typesjekkeren begrenser hvor dypt den vil instansiere dem. Hvis du når grensen, får du en dybdefeil.
// Excessively deep recursive types can produce:
// "Type instantiation is excessively deep and possibly infinite."Hvor dybdefeil kommer fra
Betingede typer som rekurserer uten et tydelig, stadig mindre basistilfelle, kan komme ut av kontroll, særlig når de kombineres med store unioner eller bygging av tupler.
type Repeat<N extends number, Acc extends unknown[] = []> =
Acc["length"] extends N ? Acc : Repeat<N, [...Acc, unknown]>;
// Large N can exceed the instantiation depth.
type Five = Repeat<5>;En trygg, avgrenset rekursjon
Hold rekursjonen grunn og avgrenset. Det er uproblematisk å bygge en liten tuppel; basistilfellet Acc["length"] extends N stopper den raskt.
type Tuple<N extends number, Acc extends unknown[] = []> =
Acc["length"] extends N ? Acc : Tuple<N, [...Acc, unknown]>;
type Three = Tuple<3>; // [unknown, unknown, unknown]
const t: Three = [1, 2, 3];
console.log(t.length);Hale-rekursive typemønstre
TypeScript optimaliserer visse hale-rekursive betingede typer ved å føre med seg en akkumulator, slik at de kan rekursere dypere enn naiv nesting.
type Reverse<T extends unknown[], Acc extends unknown[] = []> =
T extends [infer Head, ...infer Tail]
? Reverse<Tail, [Head, ...Acc]>
: Acc;
type R = Reverse<[1, 2, 3]>; // [3, 2, 1]
const r: R = [3, 2, 1];
console.log(r);Hvorfor akkumulatorer hjelper
Ved å føre resultatene videre i en akkumulator holder du rekursjonen i hale-posisjon, noe TypeScript kan rulle ut mer effektivt enn dypt nestede betingelser.
type Join<T extends string[], Acc extends string = ""> =
T extends [infer H extends string, ...infer R extends string[]]
? Join<R, Acc extends "" ? H : Acc>
: Acc;
type First = Join<["a", "b", "c"]>; // "a"
const f: First = "a";
console.log(f);Unngå rekursjon som ikke er hale-rekursiv
Hvis du pakker det rekursive kallet inn i en annen typeoperasjon, bryter du hale-posisjonen, og du kan nå grensene tidligere. Før heller tilstanden videre i en akkumulator.
// Non-tail (can be costly): builds nesting around the recursive call
// type Bad<T> = T extends [infer H, ...infer R] ? [H, ...Bad<R>] : [];
// Tail-friendly alternative uses an accumulator parameter.
console.log("prefer accumulators");Sett en eksplisitt dybdegrense
Legg til en dybdeteller slik at typen avslutter etter et fast antall nivåer, og bytter fullstendighet mot garantert terminering.
type Flatten<T, Depth extends unknown[] = []> =
Depth["length"] extends 5
? T
: T extends (infer U)[]
? Flatten<U, [...Depth, unknown]>
: T;
type X = Flatten<number[][]>; // number
const x: X = 7;
console.log(x);Praktisk dybde er vanligvis uproblematisk
Vanlige rekursive typer, lenkede lister, trær og JSON når aldri grensen fordi dataene du instansierer, er grunne. Grensene påvirker hovedsakelig omfattende beregninger på typenivå.
type Json = string | number | boolean | null | Json[] | { [k: string]: Json };
const v: Json = { a: { b: { c: 1 } } }; // fine, shallow
console.log(v);Gjenkjenne feilmeldingen
Når du ser "excessively deep and possibly infinite", bør du se etter et manglende basistilfelle, en akkumulator i en ikke-haleposisjon eller inndata som er for stor.
// Fixes: add/tighten the base case, switch to tail recursion,
// reduce input size, or cap with a depth counter.
console.log("check base case and tail position");Rekursjon ved kjøring er noe annet
Disse grensene gjelder rekursjon på typenivå. Vanlige rekursive funksjoner over rekursive typer kjører ved kjøring og begrenses bare av kallstakken.
type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function count<T>(n: TreeNode<T>): number {
return 1 + n.children.reduce((a, c) => a + count(c), 0);
}
console.log(count({ value: 1, children: [{ value: 2, children: [] }] }));Utforme kode innenfor grensene
Foretrekk grunne data, hale-rekursive mønstre med akkumulatorer og eksplisitte dybdegrenser. Med disse vanene møter du sjelden grensen i reell kode.
type Length<T extends unknown[]> = T["length"];
type N = Length<[1, 2, 3]>; // 3
const n: N = 3;
console.log(n);Kort sjekk: Rekursjonsgrenser
Test forståelsen din av rekursjonsdybde og grenser.
Oppsummering: Rekursjonsdybde og grenser
Du lærte at TypeScript setter en grense for rekursjonsdybden på typenivå, at hale-rekursive mønstre med akkumulatorer og eksplisitte dybdegrenser hjelper, og at vanlige rekursive data sjelden når grensen.
type Reverse<T extends unknown[], Acc extends unknown[] = []> =
T extends [infer H, ...infer R] ? Reverse<R, [H, ...Acc]> : Acc;
const r: Reverse<[1, 2]> = [2, 1];
console.log(r);
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 «Rekursjonsdybde og begrensninger» gratis?
Ja – hele teksten i «Rekursjonsdybde og begrensninger» 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 «Rekursjonsdybde og begrensninger»?
Forstå begrensningene for rekursjonsdybde i TypeScript. 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 4 av 4.
Hvor lang tid tar leksjonen «Rekursjonsdybde og begrensninger»?
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
- Rekursive typedefinisjoner
- Typing av trestrukturer
- JSON-verdityper
- Rekursjonsdybde og begrensninger