TypeScript Academy · Lektion

Rekursive Typdefinitionen

Schreiben Sie sicher Typen, die auf sich selbst verweisen.

Rekursive Typdefinitionen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was ist ein rekursiver Typ?

Ein rekursiver Typ ist ein Typ, der in seiner eigenen Definition auf sich selbst verweist. So können Sie Datenstrukturen mit unbegrenzter Tiefe beschreiben.

type LinkedList<T> = {
  value: T;
  next: LinkedList<T> | null;
};
// next is the same type again, ending at null.

Der Typ einer verketteten Liste

Das klassische Beispiel: Jeder Knoten enthält einen value und einen next-Zeiger auf einen weiteren Knoten oder auf null, um die Kette zu beenden.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const list: LinkedList<number> = {
  value: 1,
  next: { value: 2, next: null }
};
console.log(list.value, list.next?.value);

Der Basisfall ist wichtig

Jeder rekursive Typ benötigt einen Abschlusswert, hier null, damit die Rekursion enden kann. Ohne ihn wäre der Typ unendlich tief.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const single: LinkedList<string> = { value: "only", next: null };
console.log(single.next);

Längere Ketten erstellen

Sie können beliebig tief verschachteln. Der Typ erlaubt jede Länge, weil next selbst entweder eine Liste oder null ist.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const chain: LinkedList<number> = {
  value: 10,
  next: { value: 20, next: { value: 30, next: null } }
};
console.log(chain.next?.next?.value);

Eine verkettete Liste durchlaufen

Eine Funktion kann der Kette folgen, indem sie next verwendet, bis sie null erreicht. Der rekursive Typ macht das vollständig typsicher.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function toArray<T>(list: LinkedList<T> | null): T[] {
  const out: T[] = [];
  let cur = list;
  while (cur) { out.push(cur.value); cur = cur.next; }
  return out;
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(toArray(l));

Rekursive Funktionen über rekursiven Typen

Rekursive Typen lassen sich ganz natürlich mit rekursiven Funktionen kombinieren. Hier berechnen wir die Länge, indem wir über next rekursiv weitergehen.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function length<T>(list: LinkedList<T> | null): number {
  return list === null ? 0 : 1 + length(list.next);
}
const l: LinkedList<string> = { value: "a", next: { value: "b", next: null } };
console.log(length(l));

Ein Element an eine Liste voranstellen

Da der Typ einheitlich ist, lassen sich neue Listen einfach erstellen: Wickeln Sie eine vorhandene Liste als next eines neuen Kopfknotens ein.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function prepend<T>(value: T, list: LinkedList<T> | null): LinkedList<T> {
  return { value, next: list };
}
const l = prepend(1, prepend(2, null));
console.log(l.value, l.next?.value);

Optionale vs. nullable Abschlusswerte

Sie können mit null beenden oder next optional machen. Beides beendet die Rekursion. Wählen Sie abhängig davon, wie Sie das Ende darstellen möchten.

type ListA<T> = { value: T; next: ListA<T> | null };
type ListB<T> = { value: T; next?: ListB<T> };
const a: ListA<number> = { value: 1, next: null };
const b: ListB<number> = { value: 1 };
console.log(a.value, b.value);

Rekursive Typen werden verzögert ausgewertet

TypeScript erweitert einen rekursiven Typ nur so weit, wie Sie ihn tatsächlich verwenden. Die Definition kann auf sich selbst verweisen, ohne eine unendliche Verarbeitung zu verursachen.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
// Using two levels only expands two levels.
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(l.next?.value);

Eine Liste abbilden

Eine rekursive Map-Funktion transformiert jeden Wert, bewahrt dabei die Struktur und gibt eine neue Liste mit derselben Form zurück.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function mapList<T, U>(list: LinkedList<T> | null, fn: (v: T) => U): LinkedList<U> | null {
  if (list === null) return null;
  return { value: fn(list.value), next: mapList(list.next, fn) };
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(mapList(l, x => x * 10)?.value);

Warum rekursive Typen leistungsfähig sind

Typen, die auf sich selbst verweisen, ermöglichen es Ihnen, beliebig tief verschachtelte Daten, Listen, Bäume und JSON mit vollständiger Typsicherheit zu modellieren, ohne eine feste Tiefengrenze im Entwurf.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<boolean> = { value: true, next: { value: false, next: null } };
console.log(l.value, l.next?.value);

Kurzer Check: Rekursive Typen

Testen Sie Ihr Verständnis rekursiver Typdefinitionen.

Zusammenfassung: Rekursive Typdefinitionen

Sie haben gelernt, dass ein rekursiver Typ auf sich selbst verweist, einen Basisfall wie null zum Beenden benötigt und sich ganz natürlich mit rekursiven Funktionen kombinieren lässt, um verkettete Listen zu durchlaufen, abzubilden und zu erstellen.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<number> = { value: 1, next: null };
console.log(l.value);

Häufig gestellte Fragen

Ist die Lektion „Rekursive Typdefinitionen“ kostenlos?

Ja — der vollständige Text von „Rekursive Typdefinitionen“ 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 „Rekursive Typdefinitionen“?

Schreiben Sie sicher Typen, die auf sich selbst verweisen. 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 1 von 4.

Wie lange dauert die Lektion „Rekursive Typdefinitionen“?

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