TypeScript Academy · Lektion

Rekursionstiefe und -grenzen

Verstehen Sie die Grenzen der Rekursionstiefe von TypeScript.

Rekursionstiefe und -grenzen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

TypeScript hat Rekursionsgrenzen

Rekursive Typen sind leistungsfähig, aber der Typprüfer begrenzt, wie tief er sie instanziiert. Wenn Sie diese Grenze erreichen, erhalten Sie einen Tiefenfehler.

// Excessively deep recursive types can produce:
// "Type instantiation is excessively deep and possibly infinite."

Woher Tiefenfehler kommen

Bedingte Typen, die ohne einen klaren, schrumpfenden Basisfall rekursiv sind, können sich aufschaukeln, insbesondere in Kombination mit großen Unions oder beim Erstellen von Tupeln.

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>;

Sichere Rekursion mit Begrenzung

Halten Sie die Rekursion flach und begrenzt. Das Erstellen eines kleinen Tupels ist unproblematisch; der Basisfall Acc["length"] extends N beendet sie umgehend.

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);

Tail-rekursive Typmuster

TypeScript optimiert bestimmte tail-rekursive bedingte Typen, indem ein Akkumulator mitgeführt wird. Dadurch ist eine tiefere Rekursion möglich als bei einer naiven Verschachtelung.

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);

Warum Akkumulatoren helfen

Wenn Sie Ergebnisse in einem Akkumulator weitergeben, bleibt die Rekursion in der Tail-Position. TypeScript kann sie dadurch effizienter abrollen als tief verschachtelte Bedingungen.

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);

Nicht-tail-rekursive Muster vermeiden

Wenn Sie den rekursiven Aufruf in eine weitere Typoperation einschließen, verlassen Sie die Tail-Position und erreichen die Grenzen möglicherweise früher. Führen Sie den Zustand stattdessen in einem Akkumulator mit.

// 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");

Tiefe explizit begrenzen

Fügen Sie einen Tiefenzähler hinzu, damit der Typ nach einer festgelegten Anzahl von Ebenen abbricht. Dadurch tauschen Sie Vollständigkeit gegen garantiertes Beenden.

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);

Die praktische Rekursionstiefe ist meist unproblematisch

Alltägliche rekursive Typen wie verkettete Listen, Bäume und JSON erreichen das Limit nie, weil die instanziierten Daten flach sind. Die Grenzen betreffen hauptsächlich aufwendige Berechnungen auf Typebene.

type Json = string | number | boolean | null | Json[] | { [k: string]: Json };
const v: Json = { a: { b: { c: 1 } } }; // fine, shallow
console.log(v);

Die Fehlermeldung erkennen

Wenn Sie "excessively deep and possibly infinite" sehen, suchen Sie nach einem fehlenden Basisfall, einem Akkumulator in nicht-Tail-Position oder einer zu großen Eingabe.

// 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");

Laufzeitrekursion ist davon getrennt

Diese Grenzen betreffen die Rekursion auf Typebene. Gewöhnliche rekursive Funktionen über rekursive Typen laufen zur Laufzeit und werden nur durch den Aufrufstapel begrenzt.

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: [] }] }));

Innerhalb der Grenzen entwerfen

Bevorzugen Sie flache Daten, tail-rekursive Muster mit Akkumulatoren und explizite Tiefenbegrenzungen. Mit diesen Gewohnheiten erreichen Sie das Limit in realem Code nur selten.

type Length<T extends unknown[]> = T["length"];
type N = Length<[1, 2, 3]>; // 3
const n: N = 3;
console.log(n);

Schnelltest: Rekursionsgrenzen

Testen Sie Ihr Verständnis von Rekursionstiefe und Rekursionsgrenzen.

Zusammenfassung: Rekursionstiefe und -grenzen

Sie haben gelernt, dass TypeScript die Rekursionstiefe auf Typebene begrenzt, dass tail-rekursive Muster mit Akkumulatoren und explizite Tiefenbegrenzungen helfen und dass alltägliche rekursive Daten das Limit nur selten erreichen.

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);

Häufig gestellte Fragen

Ist die Lektion „Rekursionstiefe und -grenzen“ kostenlos?

Ja — der vollständige Text von „Rekursionstiefe und -grenzen“ 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 „Rekursionstiefe und -grenzen“?

Verstehen Sie die Grenzen der Rekursionstiefe von TypeScript. 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 4 von 4.

Wie lange dauert die Lektion „Rekursionstiefe und -grenzen“?

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

← Zurück zu TypeScript Academy