TypeScript Academy · Lektion

Bedingungen auf Typebene

Verzweigen Sie anhand von Typen mit bedingten Typausdrücken.

Bedingungen auf Typebene ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Das If auf Typebene

Die Typsprache erhält mit bedingten Typen Verzweigungen. Die Syntax T extends U ? X : Y bedeutet: Wenn T U zugewiesen werden kann, ist das Ergebnis X, andernfalls Y.

Das ist das Gegenstück auf Typebene zu einem if / else-Ausdruck.

type IsString<T> = T extends string ? "yes" : "no";

type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"

extends bedeutet zuweisbar

Der Test prüft nicht auf Gleichheit. T extends U ist wahr, wenn ein Wert vom Typ T an einer Stelle verwendet werden könnte, an der ein U erwartet wird. Literaltypen können ihrem Basistyp zugewiesen werden.

type T1 = "hello" extends string ? true : false; // true
type T2 = string extends "hello" ? true : false; // false
type T3 = 42 extends number ? true : false;       // true

Den Ergebnistyp auswählen

Bedingte Typen ermöglichen es, dass ein Generic je nach Eingabe unterschiedliche Formen zurückgibt. Hier umschließt Wrap Arrays anders als skalare Werte.

type Wrap<T> = T extends unknown[]
  ? { list: T }
  : { value: T };

type A = Wrap<number>;   // { value: number }
type B = Wrap<string[]>; // { list: string[] }

Mit never filtern

Ein verbreiteter Trick besteht darin, in einem Zweig never zurückzugeben. never bedeutet „kein Wert“ und eignet sich dazu, später Elemente aus Vereinigungen zu entfernen.

type OnlyStrings<T> = T extends string ? T : never;

type A = OnlyStrings<string>; // string
type B = OnlyStrings<number>; // never

Ableiten mit infer

Die eigentliche Stärke zeigt sich mit dem Schlüsselwort infer. Innerhalb eines bedingten Typs führt infer eine neue Typvariable ein, die einen Teil des passenden Typs erfasst.

Hier erfassen wir den Elementtyp eines Arrays.

type ElementType<T> = T extends (infer U)[] ? U : never;

type A = ElementType<number[]>; // number
type B = ElementType<string[]>; // string

Funktionsergebnisse ableiten

Sie können infer an beliebiger Stelle im Muster platzieren. Um den Rückgabetyp einer Funktion zu extrahieren, leiten Sie den Teil nach dem Pfeil ab. So funktioniert auch das integrierte Hilfsmittel ReturnType.

type MyReturn<T> = T extends (...args: any[]) => infer R ? R : never;

type A = MyReturn<() => number>;      // number
type B = MyReturn<(x: string) => boolean>; // boolean

Mehrere Teile ableiten

Ein einzelner bedingter Typ kann gleichzeitig mehrere infer-Variablen einführen. Hier extrahieren wir sowohl das erste Element als auch den Rest eines Tupels.

type FirstRest<T> = T extends [infer H, ...infer R]
  ? { head: H; rest: R }
  : never;

type A = FirstRest<[1, 2, 3]>;
// { head: 1; rest: [2, 3] }

Verschachtelte Bedingungen

Bedingte Typen lassen sich genauso wie verkettete else if-Anweisungen verschachteln. Der else-Zweig eines bedingten Typs kann selbst wieder ein bedingter Typ sein, wodurch eine Entscheidungskette entsteht.

type Describe<T> =
  T extends string ? "text" :
  T extends number ? "num" :
  T extends boolean ? "flag" :
  "other";

type A = Describe<number>; // "num"
type B = Describe<null>;   // "other"

Bedingungen als Schutzmechanismen

Verwenden Sie einen bedingten Typ, um eine Struktur zu überprüfen, bevor Sie etwas daraus extrahieren. Wenn die Eingabe nicht passt, greifen Sie auf never zurück, damit eine falsche Verwendung sichtbar wird.

type GetName<T> = T extends { name: infer N } ? N : never;

type A = GetName<{ name: string }>; // string
type B = GetName<{ age: number }>;  // never

Bedingungen kombinieren

Sie können mehrere Bedingungen verlangen, indem Sie sie verschachteln. Hier muss ein Typ sowohl ein Objekt sein als auch über eine id verfügen, um zu bestehen.

type RequireId<T> =
  T extends object
    ? T extends { id: unknown } ? T : never
    : never;

type A = RequireId<{ id: 1; x: 2 }>; // { id: 1; x: 2 }
type B = RequireId<{ x: 2 }>;        // never

Bedingte Typen überall

Die meisten integrierten Utility-Typen sind im Kern bedingte Typen: NonNullable, Extract, Exclude, Parameters und ReturnType. Wenn Sie extends ? : verstehen, erschließen sich Ihnen alle diese Typen.

type MyNonNullable<T> = T extends null | undefined ? never : T;

type A = MyNonNullable<string | null>; // string

Schnelltest

Überprüfen Sie Ihr Verständnis von bedingten Typen und infer.

Zusammenfassung

Bedingte Typen verleihen der Typsprache ein if/else und Pattern Matching.

T extends U ? X : Y verzweigt abhängig von der Zuweisbarkeit.
infer erfasst passende Teile in neuen Variablen.
Bedingte Typen lassen sich zu Entscheidungsketten verschachteln.
Durch die Rückgabe von never werden Elemente herausgefiltert.

Als Nächstes: Einen bedingten Typ in sich selbst zurückführen – für Rekursion.

Häufig gestellte Fragen

Ist die Lektion „Bedingungen auf Typebene“ kostenlos?

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

Verzweigen Sie anhand von Typen mit bedingten Typausdrücken. 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 2 von 4.

Wie lange dauert die Lektion „Bedingungen 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