Einführung in bedingte Typen

Bedingte Typen in TypeScript ermöglichen es Ihnen, Typen zu erstellen, die sich dynamisch anhand einer Bedingung anpassen. Dadurch wird Ihr Code flexibler und wiederverwendbar.

Sie verwenden eine Syntax, die dem bedingten (ternary) Operator von JavaScript ähnelt.

Was sind bedingte Typen?

Bedingte Typen ermöglichen es Ihnen, einen Typ zu definieren, der von einem anderen Typ abhängt. Die grundlegende Syntax lautet:

T extends U ? X : Y

Das bedeutet: Wenn T U erweitert, ist der Typ X, andernfalls ist er Y.

Ein einfaches Beispiel für bedingte Typen

Hier sehen Sie ein einfaches Beispiel:

type IsString<T> = T extends string ? 'Yes' : 'No';

// Test cases
type A = IsString<string>; // 'Yes'
type B = IsString<number>; // 'No'

Bedingte Typen für Funktionsüberladungen verwenden

Bedingte Typen können Funktionsüberladungen vereinfachen, indem sie die Rückgabetypen dynamisch bestimmen:

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

function getData(): string {
  return 'Hello';
}

type DataType = ReturnType<typeof getData>; // string

Distributive bedingte Typen

Wenn bedingte Typen auf Union-Typen angewendet werden, werden sie auf jedes Element der Union verteilt:

type ToArray<T> = T extends any ? T[] : never;

type A = ToArray<string | number>;
// A = string[] | number[]

Bedingte Typen mit Mapped Types kombinieren

Sie können bedingte Typen mit Mapped Types kombinieren, um leistungsfähige Typtransformationen zu erstellen:

type User = {
  id: number;
  name: string;
  isAdmin?: boolean;
};

type MakeRequired<T> = {
  [K in keyof T]-?: T[K] extends undefined ? never : T[K];
};

type RequiredUser = MakeRequired<User>;
// { id: number; name: string; isAdmin: never; }

Häufige Anwendungsfälle für bedingte Typen

Bedingte Typen werden häufig verwendet für:

• Das Ermitteln von Rückgabetypen oder Parametern.
• Das Transformieren von Unions und Schnittmengen.
• Das Erstellen von Utility-Typen wie Exclude, Extract und NonNullable.

Übungsaufgabe

Erstellen Sie einen bedingten Typ, der prüft, ob ein Typ ein Array ist, und in diesem Fall dessen Elementtyp zurückgibt. Andernfalls gibt er den Typ selbst zurück.

Herzlichen Glückwunsch!

Sie haben gelernt, wie Sie bedingte Typen verwenden, um dynamische und wiederverwendbare Typdefinitionen in TypeScript zu erstellen. Üben Sie diese Konzepte, um leistungsfähigerem und flexiblerem TypeScript-Code zu schreiben!