0Pricing
TypeScript Academy · Lektion

Bedingte Typen: T extends U ? X : Y

Schreiben Sie mit bedingten Typen if-Anweisungen auf Typebene.

Bedingte Typen: T extends U ? X : Y 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.

Willkommen

Bedingte Typen ermöglichen Ihnen, Wenn-Dann-Anweisungen auf Typebene auszudrücken. Sie sind ein zentraler Bestandteil des fortgeschrittenen Typsystems von TypeScript und werden zum Erstellen von Hilfstypen verwendet.

Grundlegende Syntax

Schreiben Sie `T extends U ? X : Y`. Wenn T U zugewiesen werden kann, ist das Ergebnis X, andernfalls Y.
type IsString<T> = T extends string ? true : false;
type A = IsString<string>; // true
type B = IsString<number>; // false

Integrierter Typ NonNullable

`NonNullable` wird mit einem bedingten Typ implementiert, der `null` und `undefined` aus T entfernt.
type NonNullable<T> = T extends null | undefined ? never : T;
type C = NonNullable<string | null>; // string

Bedingte Typen mit Generics

Bedingte Typen sind innerhalb generischer Funktionen und von Typaliasen besonders nützlich.
type Flatten<T> = T extends Array<infer I> ? I : T;
type Str = Flatten<string[]>; // string
type Num = Flatten<number>;   // number

Verschachtelte bedingte Typen

Bedingte Typen können für komplexere Logik verschachtelt werden.
type TypeName<T> =
  T extends string ? 'string' :
  T extends number ? 'number' :
  T extends boolean ? 'boolean' :
  'object';

Verteilung über Unions

Wenn T ein unverpackter Typparameter ist, verteilt sich ein bedingter Typ über die Mitglieder einer Union.
type ToArray<T> = T extends any ? T[] : never;
type R = ToArray<string | number>; // string[] | number[]

Verteilung verhindern

Verpacken Sie T in ein Tupel, um die Verteilung zu verhindern.
type NoDistribute<T> = [T] extends [any] ? T[] : never;
type R2 = NoDistribute<string | number>; // (string | number)[]

Mit never filtern

Wenn ein bedingter Typ `never` zurückgibt, werden die entsprechenden Mitglieder aus der Union entfernt.
type OnlyStrings<T> = T extends string ? T : never;
type S = OnlyStrings<'a' | 'b' | 1 | 2>; // 'a' | 'b'

Bedingte Typen in Mapped Types

Kombinieren Sie Mapped Types und bedingte Typen, um Objekteigenschaften selektiv zu transformieren.
type NullableValues<T> = { [K in keyof T]: T[K] extends string ? null : T[K] };

Aus Funktionsparametern ableiten

Verwenden Sie `infer` in bedingten Typen, um Teile komplexer Typen zu extrahieren.
type FirstParam<T> = T extends (first: infer P, ...rest: any[]) => any ? P : never;
type FP = FirstParam<(a: string, b: number) => void>; // string

Integrierte bedingte Hilfstypen

Viele integrierte Hilfstypen (`ReturnType`, `Parameters`, `InstanceType`) werden mit bedingten Typen und `infer` erstellt.
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

Kurztest

Was ist das Ergebnis von `type R = string extends object ? 'yes' : 'no'`?

Zusammenfassung

Bedingte Typen (`T extends U ? X : Y`) ermöglichen Logik auf Typebene. Sie verteilen sich über Unions, funktionieren zur Extraktion mit `infer` und bilden die Grundlage vieler integrierter Hilfstypen von TypeScript.

Häufig gestellte Fragen

Ist die Lektion „Bedingte Typen: T extends U ? X : Y“ kostenlos?

Ja — der vollständige Text von „Bedingte Typen: T extends U ? X : Y“ 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 „Bedingte Typen: T extends U ? X : Y“?

Schreiben Sie mit bedingten Typen if-Anweisungen auf Typebene. 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 „Bedingte Typen: T extends U ? X : Y“?

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

  1. keyof und Indexed-Access-Typen
  2. Generische Einschränkungen: Typparameter eingrenzen
  3. Bedingte Typen: T extends U ? X : Y
  4. Distributive bedingte Typen
← Zurück zu TypeScript Academy