TypeScript Type Guards

Typwächter sind ein sehr wichtiger Mechanismus zur Typverengung in TypeScript.

Sie ermöglichen Entwicklern, spezifische Laufzeit-Bedingungsprüfungen zu verwenden, damit der TypeScript-Compiler den spezifischen Typ einer Variable genau ableiten kann.

Mit Typwächtern können wir sicher auf Eigenschaften und Methoden eines spezifischen Typs innerhalb einer Union-Typ-Variable zugreifen.


Warum brauchen wir Typwächter?

In TypeScript kann eine Variable als Union mehrerer Typen deklariert werden.

Wenn wir je nach spezifischem Typ unterschiedliche Operationen ausführen müssen, kann der Compiler den aktuellen konkreten Typ nicht automatisch bestimmen.

Typwächter sind der Schlüsselmechanismus zur Lösung dieses Problems.

Konzepterklärung:Das Kernprinzip von Typwächtern ist die "Typverengung". Durch bedingte Prüfungen engt TypeScript einen Union-Typ automatisch auf einen spezifischen Typ ein.


SVG-Diagramm: Ablauf des Typwächters Background Title Type Guard - Type Narrowing Flow Left: Union Type Original Union Type string | number | boolean Arrow 1 typeof Middle: typeof string typeof === "string" Narrowed to string Arrow 2 Branch Right: Result Type determined Can access .length Bottom: Type Guard Types Type Guard Methods Method 1 typeof typeof x === "string" Primitive type Method 2 instanceof x instanceof Array Class instance Method 3 Custom guard x is String value is Type Method 4 in "prop" in x Property check Arrow markers

typeof-Typwächter

typeof ist der am häufigsten verwendete Typwächter und wird verwendet, um primitive Typen (string, number, boolean usw.) zu prüfen.

Er gibt einen String zurück, der den Typ des Werts angibt.

typeof: Grundlegende Verwendung

// Definiere eine Funktion, die einen Union-Typ entgegennimmt
// Der Parameter value könnte vom Typ string oder number sein
function printValue(value: string | number): void {
    // Verwende typeof, um den Typ zu prüfen
    // Wenn die if-Bedingung wahr ist, verengt TypeScript value automatisch auf den Typ string
    if (typeof value === "string") {
        // An dieser Stelle weiß TypeScript, dass value ein string ist
        // Kann sicher auf die length-Eigenschaft des string zugreifen
        console.log("Stringlänge: " + value.length);
    } else {
        // Im else-Zweig weiß TypeScript, dass value kein string ist
        // Es kann nur vom Typ number sein
        // Kann sicher mathematische Operationen ausführen
        console.log("Verdoppelte Zahl: " + (value * 2));
    }
}

// Testaufrufe
printValue("hello");  // Einen String übergeben
printValue(42);       // Eine Zahl übergeben

Ausgabe:

字符串长度: 5
数字翻倍: 84

Von typeof unterstützte Typen:

  • "string"- string-Typ
  • "number"- number-Typ (einschließlich NaN und Infinity)
  • "boolean"- boolean-Typ
  • "undefined"- undefined-Typ
  • "object"- Objekttyp (Hinweis: Arrays und null werden ebenfalls als "object" erkannt)
  • "function"- Funktionstyp

Hinweis:typeof gibt sowohl für Arrays als auch für null "object" zurück. Wenn Sie Arrays präzise von Objekten unterscheiden müssen, müssen Sie andere Methoden verwenden.


instanceof-Typwächter

instanceof wird verwendet, um zu prüfen, ob ein Objekt eine Instanz einer bestimmten Klasse ist.

Es bestimmt den Typ, indem es die Prototypenkette des Objekts überprüft.

Grundlegende Verwendung von instanceof

// Definiere eine Dog-Klasse
class Dog {
    // Die bark-Methode des Hundes
    bark(): void {
        console.log("Wuff wuff wuff!");
    }
}

// Definiere eine Cat-Klasse
class Cat {
    // Die meow-Methode der Katze
    meow(): void {
        console.log("Miau miau miau!");
    }
}

// Funktion, die einen Union-Typ empfängt
function makeSound(animal: Dog | Cat): void {
    // Verwende instanceof, um zu prüfen, ob animal ein Dog oder eine Cat ist
    // Wenn die if-Bedingung wahr ist, verengt TypeScript animal auf den Typ Dog
    if (animal instanceof Dog) {
        // An dieser Stelle kannst du Dog-spezifische Methoden aufrufen
        animal.bark();
    } else {
        // Im else-Zweig verengt TypeScript animal auf den Typ Cat
        animal.meow();
    }
}

// Testaufrufe
makeSound(new Dog());  // Erstelle eine Dog-Instanz und rufe sie auf
makeSound(new Cat());  // Erstelle eine Cat-Instanz und rufe sie auf

Ausgabe:

Woof woof woof!
Meow meow meow!

Erklärung:

instanceof prüft die Prototypenkette des Objekts, daher kann es nur mit Klasseninstanzen verwendet werden, nicht mit Interfaces oder Typaliasen.


Benutzerdefinierte Typwächter

Wenn die eingebauten typeof und instanceof die Anforderungen nicht erfüllen, können Sie benutzerdefinierte Typwächterfunktionen erstellen.

Benutzerdefinierte Typwächter verwendenvalue is Typedie Rückgabetyp-Syntax.

Benutzerdefinierte Wächterfunktionen

// Definiere eine benutzerdefinierte Typwächterfunktion
// Der Rückgabetyp verwendet das Format "value is Type"
// Dies teilt TypeScript mit: Wenn die Funktion true zurückgibt, ist der Parametertyp string
function isString(value: any): value is string {
    // Verwende typeof, um zu prüfen, ob es ein String ist
    return typeof value === "string";
}

// Ein weiterer benutzerdefinierter Guard: Prüfe, ob es eine Zahl ist
function isNumber(value: any): value is number {
    return typeof value === "number";
}

// Definiere einen Type Guard für Arrays
function isArray(value: any): value is any[] {
    return Array.isArray(value);
}

// Eine Funktion, die Werte verarbeitet
function processValue(value: string | number | any[]): void {
    // Verwende benutzerdefinierte Guards für die Typprüfung
    if (isString(value)) {
        // TypeScript weiß, dass value vom Typ string ist
        // Kann die Methode toUpperCase() aufrufen
        console.log("Zeichenkette in Großbuchstaben: " + value.toUpperCase());
    } else if (isNumber(value)) {
        // TypeScript weiß, dass value vom Typ number ist
        // Kann die Methode toFixed() aufrufen
        console.log("Formatierte Zahl: " + value.toFixed(2));
    } else if (isArray(value)) {
        // TypeScript weiß, dass value vom Typ array ist
        console.log("Array-Länge: " + value.length);
    }
}

// Testaufrufe
processValue("hello");
processValue(3.14159);
processValue([1, 2, 3, 4, 5]);

Ausgabe:

字符串转大写: HELLO
数字格式化: 3.14
数组长度: 5

Tipp:Der Schlüssel zu einem benutzerdefinierten Type Guard ist der Rückgabetypvalue is Type, der Marker, den TypeScript verwendet, um einen Type Guard zu identifizieren.


in-Operator Type Guard

Der in-Operator kann prüfen, ob ein Objekt eine bestimmte Eigenschaft enthält.

Wenn der in-Operator in bedingten Prüfungen verwendet wird, schränkt TypeScript den Typbereich des Objekts automatisch ein.

Verwendung des in-Operators

// Definiere zwei Interfaces mit unterschiedlichen Eigenschaften
interface A {
    a: string;  // Hat nur die Eigenschaft a
}

interface B {
    b: number;  // Hat nur die Eigenschaft b
}

// Funktion, die einen Union-Typ empfängt
function process(obj: A | B): void {
    // Verwende in, um zu prüfen, ob das Objekt die Eigenschaft "a" enthält
    if ("a" in obj) {
        // Im if-Zweig weiß TypeScript, dass obj die Eigenschaft a enthält
        // Daher wird der Typ von obj auf A eingeschränkt
        console.log("Eigenschaft a von A: " + obj.a);
    } else {
        // Im else-Zweig enthält obj die Eigenschaft a nicht
        // TypeScript weiß, dass obj nur vom Typ B sein kann
        // Daher können Sie sicher auf Eigenschaft b zugreifen
        console.log("Eigenschaft b von B: " + obj.b);
    }
}

// Testaufrufe
process({ a: "hello" });  // Übergeben Sie ein Objekt, das die Eigenschaft a enthält
process({ b: 42 });       // Übergeben Sie ein Objekt, das die Eigenschaft b enthält

Ausführungsergebnis:

A 的属性 a: hello
B 的属性 b: 42

Diskriminierte Unions und Type Guards

Eine diskriminierte Union ist ein mächtiges Muster, das die Mitglieder eines Union-Typs anhand einer gemeinsamen "Diskriminante"-Eigenschaft unterscheidet.

In Kombination mit switch-Anweisungen oder if-Prüfungen lassen sich vollständige Type Guards implementieren.

Implementierung eines Taschenrechners mit diskriminierten Unions

// Definiere die Circle-Schnittstelle, wobei die kind-Eigenschaft als Diskriminante verwendet wird
interface Circle {
    kind: "circle";       // Diskriminantenfeld: Wert ist "circle"
    radius: number;       // Radius
}

// Definiere die Rectangle-Schnittstelle
interface Rectangle {
    kind: "rectangle";    // Diskriminantenfeld: Wert ist "rectangle"
    width: number;        // Breite
    height: number;      // Höhe
}

// Definiere die Triangle-Schnittstelle
interface Triangle {
    kind: "triangle";    // Diskriminantenfeld: Wert ist "triangle"
    base: number;        // Basis
    height: number;      // Höhe
}

// Union-Typ definieren
type Shape = Circle | Rectangle | Triangle;

// Funktion zur Berechnung der Fläche
function getArea(shape: Shape): number {
    // Switch-Anweisung zur Typabsicherung verwenden
    // Basierend auf dem Wert der kind-Eigenschaft verengt TypeScript automatisch den Typ
    switch (shape.kind) {
        case "circle":
            // shape wird auf den Typ Circle verengt
            // Zugriff auf die radius-Eigenschaft möglich
            return Math.PI * shape.radius ** 2;

        case "rectangle":
            // shape wird auf den Typ Rectangle verengt
            // Zugriff auf die Eigenschaften width und height möglich
            return shape.width * shape.height;

        case "triangle":
            // shape wird auf den Typ Triangle eingegrenzt
            return 0.5 * shape.base * shape.height;
    }
}

// Testaufrufe
var circle = { kind: "circle" as const, radius: 5 };
var rectangle = { kind: "rectangle" as const, width: 4, height: 6 };
var triangle = { kind: "triangle" as const, base: 3, height: 4 };

console.log("Kreisfläche: " + getArea(circle).toFixed(2));
console.log("Rechteckfläche: " + getArea(rectangle));
console.log("Dreiecksfläche: " + getArea(triangle));

Ausführungsergebnis:

圆形面积: 78.54
矩形面积: 24
三角形面积: 6

Hinweis:Diskriminierte Unions sind eines der am meisten empfohlenen Muster in TypeScript. Sie unterscheiden verschiedene Typmember durch eine gemeinsame Literaleigenschaft (normalerweise kind oder type), wodurch der Code sowohl typsicher als auch leicht zu warten ist.


null- und undefined-Überprüfungen

Beim Umgang mit Werten, die null oder undefined sein können, sind direkte Gleichheitsprüfungen ebenfalls wirksame Type Guards.

Nullprüfung

// Definiere einen Funktionsparameter, der null sein kann
function getLength(str: string | null): number {
    // Prüfe direkt, ob str ungleich null ist
    // Wenn die Bedingung wahr ist, weiß TypeScript, dass str nicht null ist
    // An diesem Punkt kann sicher auf die Eigenschaften von str zugegriffen werden
    if (str !== null) {
        return str.length;
    }

    // Behandlung des Nullfalls
    return 0;
}

// Testaufrufe
console.log(getLength("hello"));  // Normaler String
console.log(getLength(null));      // null übergeben

Ausführungsergebnis:

5
0

Tipp:Nach dem Aktivieren von strictNullChecks wird empfohlen, immer Nullprüfungen durchzuführen. Optional Chaining (?.) und Nullish Coalescing (??) können verwendet werden, um den Code zu vereinfachen.


Verengung durch Truthiness

Zusätzlich zu expliziten Typprüfungen verengt TypeScript Typbereiche auch durch Truthiness-Prüfungen.

Verengung durch Truthiness

// Ein String, der möglicherweise undefined ist
function greet(name?: string): string {
    // Verwende den Kurzschluss-Operator: Wenn name undefined oder eine leere Zeichenfolge ist, verwende einen Standardwert
    // Im Codeblock nach && weiß TypeScript, dass name einen Wert haben muss
    return name && "Hello, " + name;
}

// Test
console.log(greet("EXAMPLE"));
console.log(greet());

Ausführungsergebnis:

Hello, EXAMPLE
Hello, undefined

Wichtige Hinweise

  • Type Guards müssen in bedingten Verzweigungen verwendet werden:Erst nach Verwendung eines Type Guards für eine bedingte Prüfung führt TypeScript ein Type Narrowing durch.
  • Der Rückgabetyp muss ein Typprädikat sein:Der Rückgabetyp eines benutzerdefinierten Type Guards mussvalue is Typeformat
  • Diskriminierte Unions sind die bewährte Vorgehensweise:Für komplexe Union-Typen wird empfohlen, das Muster der diskriminierten Union zu verwenden.
  • Beachte die Vollständigkeit des Type Narrowings:Bei der Verwendung von switch-Anweisungen wird empfohlen, alle möglichen Zweige zu behandeln.

Empfehlung:Bei der Arbeit mit Union-Typen gib dem Muster der diskriminierten Union den Vorzug. Es macht den Code nicht nur klarer, sondern nutzt auch die Typinferenzfähigkeiten von TypeScript voll aus.


Zusammenfassung

Type Guards sind ein wichtiger Bestandteil des Typsystems von TypeScript.

  • typeof:Die gebräuchlichste Methode, geeignet zum Prüfen primitiver Typen.
  • instanceof:Prüft, ob ein Objekt eine Instanz einer bestimmten Klasse ist.
  • Benutzerdefinierte Guards:Durchvalue is Typedie Syntax können flexible Typprüfungen implementiert werden.
  • in:Prüfen, ob ein Objekt eine bestimmte Eigenschaft enthält.
  • Diskriminierte Unions:Empfohlenes Best-Practice-Muster, das Typen durch Diskriminanzfelder unterscheidet.
  • Truthiness-Narrowing:Nutzen Sie die Truthiness-Prüfungen von JavaScript, um Typen zu verengen.
Andere Erweiterungen