TypeScript Bedingte Typen

Bedingte Typen sind eine der leistungsfähigsten Funktionen im TypeScript-Typsystem.

Sie ermöglichen die dynamische Auswahl von Typen basierend auf Bedingungen, ähnlich wie ternäre Ausdrücke in Programmiersprachen.

Bedingte Typen machen Typdefinitionen flexibler und sind die Grundlage für die Implementierung fortgeschrittener Utility-Typen.


SVG-Diagramm: Ablauf bedingter Typen Background Title How Conditional Types Work Syntax Explanation Conditional Type Syntax T extends U ? X : Y Arrow Execution Flow Execution Flow Check whether T can be assigned to U → Yes → X | No → Y Example Area Example Analysis Example 1 Example 1 IsString<string> string extends string? ✓ → true Example 2 Example 2 IsString<number> number extends string? ✗ → false Example 3 Example 3 ReturnType<fn> fn extends (...args) → R (inferred return type) Arrow Marker

Warum brauchen wir bedingte Typen?

In der realen TypeScript-Entwicklung müssen wir oft unterschiedliche Typen basierend auf unterschiedlichen Eingabetypen zurückgeben.

Beispielsweise kann eine Funktion Parameter vom Typ string oder number akzeptieren, und wir müssen je nach Parametertyp unterschiedliche Ergebnistypen zurückgeben.

Bedingte Typen bieten die Möglichkeit, logische Prüfungen auf Typebene durchzuführen, wodurch Typdefinitionen flexibler und leistungsfähiger werden.

Konzepterklärung:Die Syntax bedingter Typen istT extends U ? X : YWenn der Typ T dem Typ U zugewiesen werden kann, gib den Typ X zurück; andernfalls gib den Typ Y zurück.


Grundlegende Syntax

Bedingte Typen verwenden die Syntax ternärer Ausdrücke, um bedingte Prüfungen auf Typebene durchzuführen.

Dadurch können wir den Rückgabetyp dynamisch basierend auf dem Eingabetyp berechnen.

Beispiel

// Syntax bedingter Typen: T extends U ? X : Y
// Wenn T ein String-Typ ist, true zurückgeben; andernfalls false zurückgeben
type IsString<T> = T extends string ? true : false;

// Verwendung eines bedingten Typs
// string extends string ist true, also ist Typ A true
type A = IsString<string>;
// number extends string ist false, also ist Typ B false
type B = IsString<number>;

// Verwendung dieser Typen
var a: A = true;
var b: B = false;

console.log("Ist string ein string?: " + a);
console.log("Ist number ein string?: " + b);

Ausgabe:

string 是字符串?: true
number 是字符串?: false

Erklärung:Bedingte Typen werden während der Typprüfung automatisch ausgewertet, um konkrete Typen zu erzeugen.


Praktische Anwendung: Typfilterung

Eine der häufigsten Anwendungen bedingter Typen ist die Typfilterung.

Zum Beispiel kannst du einen Typ erstellen, um null und undefined auszuschließen.

Beispiel

// Implementierung von NonNullable mit einem bedingten Typ
// Wenn T null oder undefined ist, wird never (leerer Typ) zurückgegeben; andernfalls wird T selbst zurückgegeben
type NonNullable<T> = T extends null | undefined ? never : T;

// Verwendung des NonNullable-Typs
// string ist nicht null/undefined, daher ist der Typ string
type A = NonNullable<string>;
// null ist null/undefined, daher ist der Typ never
type B = NonNullable<null>;
// undefined ist null/undefined, daher ist der Typ never
type C = NonNullable<undefined>;

// Überprüfen des Typs
var a: A = "hello";
console.log("Nicht-Null: " + a);

Ausgabe:

非空: hello

Der never-Typ:never steht für einen Typ, der niemals existiert. Wenn eine Bedingung nicht erfüllt ist, verwendet TypeScript never, um einen "nicht verfügbaren" Typ darzustellen.


Typinferenz: Das infer-Schlüsselwort

Das infer-Schlüsselwort ist eine der mächtigsten Funktionen in bedingten Typen.

Es ermöglicht das "Extrahieren" oder "Inferieren" bestimmter Typbestandteile aus einem Typ.

Beispiel

// infer verwenden, um den Rückgabetyp einer Funktion zu inferieren
// Wenn T ein Funktionstyp ist, den inferierten Rückgabetyp R zurückgeben; andernfalls never zurückgeben
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

// Eine Funktion definieren, die ein Benutzerobjekt zurückgibt
function getUser() {
    return { name: "Alice" };
}

// Definiere eine Funktion, die eine Zahl zurückgibt
function getNumber() {
    return 42;
}

// ReturnType verwenden, um den Rückgabetyp der Funktion zu erhalten
// Als { name: string } abgeleitet
type R1 = ReturnType<typeof getUser>;
// Als number abgeleitet
type R2 = ReturnType<typeof getNumber>;

// Die abgeleiteten Typen verwenden
var r1: R1 = { name: "Bob" };
var r2: R2 = 100;

console.log("Benutzer: " + JSON.stringify(r1));
console.log("Nummer: " + r2);

Ausgabe:

User: {"name":"Bob"}
数字: 100

Die Rolle von infer:infer ist wie eine "Variable" im Typsystem; es kann einen bestimmten Teil eines Typs erfassen und im resultierenden Typ verwenden.


Verteilende bedingte Typen

Wenn der generische Parameter eines bedingten Typs ein Union-Typ ist, wird die "Verteilung" automatisch angewendet.

Das heißt, die Bedingung wird auf jedes Mitglied des Union-Typs separat angewendet, und die Ergebnisse werden dann zusammengeführt.

Beispiel

// ToArray konvertiert den Typ T in einen Array-Typ
// Wenn T ein Union-Typ ist, wird jeder Typ automatisch verteilt
type ToArray<T> = T extends any ? T[] : never;

// Union-Typen werden automatisch verteilt
// string | number wird verteilt als: ToArray<string> | ToArray<number>
// d. h., string[] | number[]
type StrOrNum = ToArray<string | number>;

// Er kann string[] oder number[] zugewiesen werden
var arr: StrOrNum = ["hello"];
// Es kann auch eine Zahl zugewiesen werden
arr = 42;

console.log("Array: " + arr);

Ausgabe:

数组: 42

Verteilungsmechanismus:Das distributive Verhalten bedingter Typen ist automatisch aktiviert. Um die Verteilung zu deaktivieren, können Sie eckige Klammern verwenden:[T] extends U。


Kombinieren von bedingten Typen mit zugeordneten Typen

Bedingte Typen können mit zugeordneten Typen kombiniert werden, um leistungsstarke Dienstprogramme zur Typentransformation zu erstellen.

Diese Kombination ist die Grundlage für die Implementierung der integrierten Utility-Typen von TypeScript.

Beispiel

// Ein User-Interface definieren
interface User {
    // Benutzer-ID
    id: number;
    // Benutzername
    name: string;
    // Benutzer-E-Mail
    email: string;
}

// Partial mithilfe von zugeordneten Typen und bedingten Typen implementieren
// Über alle Eigenschaften von T iterieren und den optionalen Modifikator ? hinzufügen
type Partial<T> = {
    [P in keyof T]?: T[P];
};

// Required mit gemappten Typen und bedingten Typen implementieren
// Über alle Eigenschaften von T iterieren und den optionalen Modifikator -? entfernen
type Required<T> = {
    [P in keyof T]-?: T[P];
};

// Mit Partial: Alle Eigenschaften werden optional
var partial: Partial<User> = { name: "Alice" };

// Mit Required: Die Eigenschaften von Partial<User> erforderlich machen
// Der Typ Partial<User> muss zuerst existieren
type RequiredUser = Required<Partial<User>>;
var required: RequiredUser = { name: "Bob", id: 1 };

console.log("Optional: " + JSON.stringify(partial));
console.log("Erforderlich: " + JSON.stringify(required));

Ausgabe:

可选: {"name":"Alice"}
必填: {"name":"Bob","id":1}

Kombinierte Verwendung:Die Kombination von bedingten Typen und gemappten Typen kann verschiedene komplexe Typumwandlungen implementieren, wie die integrierten Utility-Typen Partial, Required und Readonly.


Fortgeschrittenes Beispiel: Typprüfung

Bedingte Typen können auch verwendet werden, um komplexere Typprüfungen zu implementieren.

Im Folgenden finden Sie einige nützliche Beispiele für Typprüfungen in der Praxis.

Beispiel

// Prüfen, ob der Typ any ist
// Die Schnittmenge von any mit einem beliebigen Typ ergibt any, also ist 0 extends any wahr
type IsAny<T> = 0 extends (1 & T) ? true : false;

// IsAny testen
// any ist ein spezieller Typ; die Schnittmenge mit einem beliebigen Typ ergibt any
type A = IsAny<any>;       // true
// string ist nicht any
type B = IsAny<string>;    // false

console.log("Ist any any?: " + A);
console.log("Ist string any?: " + B);

// Prüfen, ob der Typ zugewiesen werden kann
// Gibt true zurück, wenn T U zugewiesen werden kann, andernfalls gibt false zurück
type IsAssignableTo<T, U> = T extends U ? true : false;

// Typzuweisbarkeit testen
// string kann any zugewiesen werden, gibt daher true zurück
type CanAssign = IsAssignableTo<string, any>;
console.log("string zu any zuweisbar?: " + CanAssign);

Ausführungsergebnis:

any 是 any?: true
string 是 any?: true

Hinweis:any ist der "nachsichtigste" Typ in TypeScript. Er kann jedem Typ zugewiesen werden, und er kann Zuweisungen von jedem Typ entgegennehmen.


Hinweise

  • Verzögerte Auswertung:Bedingte Typen werden verzögert ausgewertet; sie werden nur berechnet, wenn konkrete Typen verwendet werden.
  • Distributive Eigenschaft:Union-Typen lösen automatisch den distributiven Mechanismus bedingter Typen aus.
  • infer kann nur in extends-Bedingungen verwendet werden:Dies ist der einzige Ort, an dem infer vorkommen kann.
  • Kombination mit gemappten Typen:Die Kombination bedingter Typen mit gemappten Typen kann leistungsstarke Utility-Typen erzeugen.

Fortgeschritten:Viele in TypeScript integrierte Utility-Typen (wie Partial, Required, Extract) sind mit bedingten Typen implementiert.


Zusammenfassung

Bedingte Typen gehören zu den leistungsstärksten Features im TypeScript-Typsystem.

  • Grundlegende Syntax:T extends U ? X : Y
  • Das infer-Schlüsselwort:Bestimmte Teile aus einem Typ ableiten.
  • Distributive Eigenschaft:Union-Typen werden automatisch verteilt.
  • Anwendungsszenarien:Typfilterung, Typinferenz, Typprüfung.
  • Utility-Typen:Die meisten integrierten Utility-Typen sind auf Basis bedingter Typen implementiert.

Best Practices:Die Beherrschung bedingter Typen ermöglicht es Ihnen, flexibleren und typsicheren Code zu schreiben.


Weitere Erweiterungen