Prüfen des Objekttyps zur Laufzeit in TypeScript

1. Haupttypen in TypeScript
2. Überprüfen Sie den Klassentyp zur Laufzeit in TypeScript
3. Überprüfen Sie den Schnittstellentyp zur Laufzeit in TypeScript

In diesem Artikel wird erläutert, wie Sie den Objekttyp zur Laufzeit in TypeScript überprüfen.

Haupttypen in TypeScript

TypeScript ist eine stark typisierte Sprache. Daher werden die Typen während der Kompilierzeit überprüft, wodurch Laufzeitfehler reduziert werden.

In TypeScript gibt es mehrere Haupttypen, wie im Folgenden gezeigt.

• Primitive Typen wie String, Zahl und Boolean
• Benutzerdefinierte Klassentypen
• Schnittstellentypen
• Unionstypen
• Geben Sie Aliase ein

Überprüfen Sie den Klassentyp zur Laufzeit in TypeScript

TypeScript unterstützt das Schlüsselwort class aus EcmaScript 6. Es kann verwendet werden, um Ihren Code auf OOP-Weise zu schreiben.

Lassen Sie uns die Klasse Ingenieur erstellen.

class Engineer {
}

Lassen Sie uns eine Methode hinzufügen, da diese Klasse keine Eigenschaften oder Verhaltensweisen enthält.

class Engineer {
    visitSite(): void {
        console.log("This is the Engineer class");
    }
}

Nehmen wir an, wir haben eine andere Klasse, Doctor, wie im Folgenden gezeigt.

class Doctor {
    visitWard(): void {
        console.log("This is the Doctor class");
    }
}

Engineer und Doctor sind zwei benutzerdefinierte Typen. In manchen Szenarien müssen wir prüfen, ob ein vorhandener Objekttyp zur Klasse Engineer oder Doctor gehört.

Dies ist mit dem TypeScript-Operator instanceof ganz einfach.

Verwenden Sie den instanceof-Operator, um den Klassentyp zu überprüfen

Es prüft, ob das angegebene Objekt eine Instanz einer TypeScript-Klasse oder ein Konstruktor ist. Es berücksichtigt die mehrstufige Vererbung, um zu prüfen, ob die betreffende Klasse auf einer anderen Ebene vorkommt.

Wenn eine passende Klasse gefunden wird, wird true zurückgegeben; andernfalls wird false ausgegeben.

Syntax:

my_object instanceof my_custom_class_type

Lassen Sie uns diesen Operator verwenden, um innerhalb unserer TypeScript-Logik zwischen den Klassen Engineer und Doctor zu unterscheiden.

Zuerst erstellen wir eine neue Checker-Funktion checkObjectType().

function checkObjectType(myObject) {
    if (myObject instanceof Engineer) {
        myObject.visitSite()
    }
    if (myObject instanceof Doctor) {
        myObject.visitWard()
    }
}

In der obigen Checker-Funktion überprüfen wir die Klasse von myObject. Basierend auf dem Ergebnis rufen wir die zugehörigen Klassenmethoden visitSite() oder visitWard() auf.

Lassen Sie uns Objekte aus beiden Klassen initiieren und das Objekt an die Methode checkObjectType übergeben.

let engineerObject: Engineer = new Engineer;
let doctorObject: Doctor = new Doctor;
checkObjectType(engineerObject);
checkObjectType(doctorObject);

Ausgabe:

Wie erwartet identifiziert TypeScript die richtige Klasse für jedes bereitgestellte Objekt.

Überprüfen Sie den Schnittstellentyp zur Laufzeit in TypeScript

Mit instanceof kann überprüft werden, ob die angegebene Instanz zu einer Klasse gehört. Dies funktioniert jedoch nicht mit TypeScript-Schnittstellentypen oder Typaliasen.

Zur Laufzeit sind alle diese Schnittstellentypen verschwunden. Daher gibt der übliche JavaScript-Operator typeof die Ausgabe als object aus.

Lassen Sie uns zwei Schnittstellen definieren, Airplane und Car, wie im Folgenden gezeigt.

interface Airplane {
    hasWings() {
        console.log("2 wings");
    }
}

interface Car {
    hasWheels() {
        console.log("4 wheels");
    }
}

Als nächstes erstellen wir einen benutzerdefinierten Typwächter für TypeScript, um zu prüfen, ob das angegebene Objekt zum Typ Airplane oder Car gehört, und das Objekt auf einen kompatiblen Typ einzugrenzen. Hier sollten wir Typprädikat als Rückgabetyp verwenden.

Syntax des Typprädikats:

my_parameter_name is custom_type

Der my_parameter_name sollte das aktuelle Argument sein, das an die Funktion übergeben wird. In diesem Fall ist der custom_type das Airplane oder Car.

Lassen Sie uns die beiden Typwächter definieren:

function isAirplane(anyObject: any): anyObject is Airplane {
    return (anyObject as Airplane).hasWings() !=== undefined;
}

Wir überprüfen, ob die Form des Objekts der Schnittstellenform entspricht, indem wir prüfen, ob die Methode hasWings() für das übergebene Objekt anyObject verfügbar ist. Dann geben wir das Typprädikat zurück, das das Objekt auf den Typ Flugzeug eingrenzt.

Ähnlich können wir die Funktion isCar() implementieren.

function isCar(anyObject: any): anyObject is Car {
    return (anyObject as Car).hasWheels() !=== undefined;
}

Schließlich können wir die Funktion testType() implementieren, um den Code zu testen.

let car: Car = {wheels: 4};
let flight: Airplane = {wings: 2};

function testType(obj: any) {
  if (isAirplane(obj)) {
    // 'obj' is narrowed to type 'Airplane'
    console.log("Airplane wings: "+ obj.wings);
  }
  else if (isCar(obj)) {
    // 'obj' is narrowed to type 'Car'
     console.log("Car wheels: "+ obj.wheels);
  }
}

testType(car);
testType(flight);

Ausgabe:

Mit Hilfe von benutzerdefinierten Type Guards können wir den genauen Typ für Schnittstellen zur Laufzeit überprüfen.