TypeScript Academy · Lektion

Rekursion auf Typebene

Iterieren Sie mit rekursiven bedingten Typen über Typen.

Rekursion auf Typebene 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.

Rekursion in Typen

Ein bedingter Typ darf auf sich selbst verweisen. Dadurch erhält die Typsprache Schleifen. Bei der meisten Rekursion auf Typebene wird ein Tupel Element für Element durchlaufen: Der Kopf wird abgetrennt und der Rest rekursiv verarbeitet.

type Length<T extends unknown[]> =
  T extends [unknown, ...infer Rest]
    ? Length<Rest>
    : 0;
// (this counts down to a base case)

Der Basisfall

Jede Rekursion benötigt eine Abbruchbedingung. Bei Tupeln ist dies normalerweise das leere Tupel. Wenn das Muster [head, ...rest] nicht mehr passt, ist das Ende erreicht und Sie geben ein festes Ergebnis zurück.

type IsEmpty<T extends unknown[]> =
  T extends [] ? true : false;

type A = IsEmpty<[]>;     // true
type B = IsEmpty<[1, 2]>; // false

Kopf und Rest

Der zentrale Schritt besteht darin, ein Tupel mithilfe von infer und dem Spread-Muster in sein erstes Element und das verbleibende Tupel aufzuteilen.

type Head<T extends unknown[]> = T extends [infer H, ...unknown[]] ? H : never;
type Tail<T extends unknown[]> = T extends [unknown, ...infer R] ? R : [];

type A = Head<[1, 2, 3]>; // 1
type B = Tail<[1, 2, 3]>; // [2, 3]

Element für Element verarbeiten

Kombinieren Sie Kopf, Rest und Rekursion, um ein gesamtes Tupel zu transformieren. ToStrings baut das Tupel neu auf und ersetzt den Typ jedes Elements durch string.

type ToStrings<T extends unknown[]> =
  T extends [infer H, ...infer R]
    ? [string, ...ToStrings<R>]
    : [];

type A = ToStrings<[1, true, 3]>; // [string, string, string]

Das Akkumulator-Muster

Oft bauen Sie ein Ergebnis in einem zusätzlichen Parameter namens Akkumulator auf. Er beginnt leer und wächst bei jedem Schritt. Dadurch vermeiden Sie, die Struktur erneut zu durchlaufen, und verwenden die Standardtechnik für Schleifen auf Typebene.

type Reverse<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R]
    ? Reverse<R, [H, ...Acc]>
    : Acc;

type A = Reverse<[1, 2, 3]>; // [3, 2, 1]

Den Akkumulator durchlaufen

Verfolgen Sie Reverse<[1,2,3]>:

Schritt 1: H=1, Acc wird zu [1]
Schritt 2: H=2, Acc wird zu [2,1]
Schritt 3: H=3, Acc wird zu [3,2,1]
Tupel leer, Acc = [3,2,1] zurückgeben

Der Akkumulator trägt das Ergebnis in jedem rekursiven Aufruf weiter.

type R = Reverse<["a", "b"]>; // ["b", "a"]

Über Vereinigungen rekursieren

Sie können auch rekursiv vorgehen, um eine Vereinigung von Strings zusammenzufügen. Hier verketten Sie Tupel-Elemente zu einem einzigen String-Literal-Typ, getrennt durch ein Trennzeichen.

Notation: In echtem TypeScript werden Template-Literal-Typen mit durch Backticks begrenzten Zeichenfolgen geschrieben, die Dollar-geschweifte Platzhalter enthalten. In diesen Ausschnitten stellen wir dieses Muster als Tpl<...> dar und führen jeden Teil in der richtigen Reihenfolge auf; beispielsweise erscheint ein Backtick-Template, das auf das Literalpräfix und anschließend auf Rest passt, als Tpl<'prefix', infer Rest>.

type Join<T extends string[], Sep extends string = ','> =
  T extends [infer H extends string, ...infer R extends string[]]
    ? R extends []
      ? H
      : Tpl<H, Sep, Join<R, Sep>>
    : '';
// Tpl<H, Sep, ...> builds a template literal type joining the parts

type A = Join<['a', 'b', 'c']>; // 'a,b,c'

Mit Rekursion zählen

Mit Rekursion und einem Akkumulator können Sie zählen. Erstellen Sie ein Tupel aus unknown mit derselben Länge wie die Eingabe und lesen Sie später seine length aus. Sie werden dies im Kurs zur Arithmetik intensiv verwenden.

type Count<T extends unknown[], Acc extends unknown[] = []> =
  T extends [unknown, ...infer R]
    ? Count<R, [unknown, ...Acc]>
    : Acc["length"];

type A = Count<["x", "y", "z"]>; // 3

Mit Rekursion filtern

Durchlaufen Sie ein Tupel und behalten Sie nur Elemente, die einer Bedingung entsprechen; die übrigen werden verworfen. Überspringen Sie ein Element, indem Sie es nicht zum Akkumulator hinzufügen.

type KeepStrings<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R]
    ? H extends string
      ? KeepStrings<R, [...Acc, H]>
      : KeepStrings<R, Acc>
    : Acc;

type A = KeepStrings<[1, "a", 2, "b"]>; // ["a", "b"]

Grenzen der Rekursionstiefe

Der Compiler begrenzt die Rekursionstiefe (historisch auf etwa 50; Tail-Recursion-Optimierungen erlauben bei manchen Mustern mehr). Bei sehr großen Tupeln kann Type instantiation is excessively deep auftreten. Verwenden Sie den Akkumulatorstil (Tail-Stil), um das Limit höher zu setzen.

type Repeat<T, N extends number, Acc extends T[] = []> =
  Acc["length"] extends N ? Acc : Repeat<T, N, [...Acc, T]>;

type A = Repeat<0, 3>; // [0, 0, 0]

Alles zusammenfügen

Das Aufteilen in Kopf und Rest, ein Basisfall und ein Akkumulator sind die drei Bestandteile fast jeder Schleife auf Typebene. Damit können Sie Tupel vollständig im Typsystem abbilden, filtern, umkehren, zählen und zusammenfügen.

type MapToPairs<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R]
    ? MapToPairs<R, [...Acc, [H, H]]>
    : Acc;

type A = MapToPairs<[1, 2]>; // [[1, 1], [2, 2]]

Schnelltest

Überprüfen Sie Ihr Verständnis des Akkumulator-Musters.

Zusammenfassung

Sie können nun Schleifen auf Typebene schreiben.

Selbstreferenzielle bedingte Typen erzeugen Rekursion.
Teilen Sie Tupel in [H, ...R] auf und rekursieren Sie über den Rest.
Ein Basisfall (leeres Tupel) beendet die Schleife.
Ein Akkumulator baut das Ergebnis auf und ermöglicht tiefe Rekursion.

Als Nächstes: Wie sich bedingte Typen bei Vereinigungen besonders verhalten.

Häufig gestellte Fragen

Ist die Lektion „Rekursion auf Typebene“ kostenlos?

Ja — der vollständige Text von „Rekursion auf Typebene“ 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 „Rekursion auf Typebene“?

Iterieren Sie mit rekursiven bedingten Typen über Typen. 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 „Rekursion auf Typebene“?

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