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
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 ist
T 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
// 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
// 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
// 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
// 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
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
// 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