Klassentypprüfung in TypeScript

Question

In ActionScript ist es möglich, den Typ zur Laufzeit zu überprüfen, indem man die ist Betreiber :

var mySprite:Sprite = new Sprite(); 
trace(mySprite is Sprite); // true 
trace(mySprite is DisplayObject);// true 
trace(mySprite is IEventDispatcher); // true

Ist es möglich, zu erkennen, ob eine Variable (erweitert oder) ist eine bestimmte Klasse oder Schnittstelle mit TypeScript?

Ich konnte in den Sprachspezifikationen nichts darüber finden. Es sollte bei der Arbeit mit Klassen/Schnittstellen vorhanden sein.

Answer 1

4.19.4 Der instanceof-Operator

En instanceof Operator erfordert, dass der linke Operand vom Typ Any, einem Objekttyp oder einem Typ-Parameter-Typ ist und der rechte Operand vom Typ Any oder einem Subtyp des Schnittstellentyps 'Function' ist. Das Ergebnis ist immer vom primitiven Typ Boolean.

Sie könnten also verwenden

mySprite instanceof Sprite;

Beachten Sie, dass es diesen Operator auch in ActionScript gibt, er dort aber nicht mehr verwendet werden sollte:

Mit dem is-Operator, der neu in ActionScript 3.0 ist, können Sie testen, ob eine Variable oder ein Ausdruck zu einem bestimmten Datentyp gehört. In früheren Versionen von ActionScript bot der instanceof-Operator diese Funktionalität, aber in ActionScript 3.0 sollte der instanceof-Operator nicht zum Testen der Zugehörigkeit zu einem Datentyp verwendet werden. Der is-Operator sollte anstelle des instanceof-Operators für die manuelle Typüberprüfung verwendet werden, da der Ausdruck x instanceof y lediglich die Prototypenkette von x auf das Vorhandensein von y überprüft (und in ActionScript 3.0 bietet die Prototypenkette kein vollständiges Bild der Vererbungshierarchie).

TypeScripts instanceof hat die gleichen Probleme. Da es sich um eine Sprache handelt, die sich noch in der Entwicklung befindet, empfehle ich Ihnen, einen Vorschlag für eine solche Möglichkeit zu unterbreiten.

Siehe auch:

• MDN: instanceof

Answer 2

TypeScript bietet eine Möglichkeit, den Typ einer Variablen zur Laufzeit zu validieren. Sie können eine Validierungsfunktion hinzufügen, die eine Typprädikat . Sie können diese Funktion also innerhalb einer if-Anweisung aufrufen und sicher sein, dass der gesamte Code innerhalb dieses Blocks sicher ist und als der Typ verwendet werden kann, von dem Sie glauben, dass er es ist.

Beispiel aus den TypeScript-Dokumenten:

function isFish(pet: Fish | Bird): pet is Fish {
   return (<Fish>pet).swim !== undefined;
}

// Both calls to 'swim' and 'fly' are now okay.
if (isFish(pet)) {
  pet.swim();
}
else {
  pet.fly();
}

Siehe mehr unter: https://www.typescriptlang.org/docs/handbook/advanced-types.html

Answer 3

Sie können die instanceof Operator für diese. Von MDN:

Der instanceof-Operator prüft, ob die Prototypeigenschaft einer Konstruktors irgendwo in der Prototypenkette eines Objekts auftaucht.

Wenn Sie nicht wissen, was Prototypen und Prototypenketten sind, empfehle ich Ihnen dringend, das nachzuschlagen. Auch hier ist ein JS (TS funktioniert ähnlich in dieser Hinsicht) Beispiel, das das Konzept klären könnte:

    class Animal {
        name;

        constructor(name) {
            this.name = name;
        }
    }

    const animal = new Animal('fluffy');

    // true because Animal in on the prototype chain of animal
    console.log(animal instanceof Animal); // true
    // Proof that Animal is on the prototype chain
    console.log(Object.getPrototypeOf(animal) === Animal.prototype); // true

    // true because Object in on the prototype chain of animal
    console.log(animal instanceof Object); 
    // Proof that Object is on the prototype chain
    console.log(Object.getPrototypeOf(Animal.prototype) === Object.prototype); // true

    console.log(animal instanceof Function); // false, Function not on prototype chain

Die Prototypenkette in diesem Beispiel ist:

animal > Animal.prototype > Object.prototype

Answer 4

Sie haben zwei Arten von Kontrollen

• typeof para grundlegend Typen und
• instanceof para komplex Typen

durch ex, die isString Prüfung kann wie folgt durchgeführt werden:

function isString(value) {
    return typeof value === 'string' || value instanceof String;
}

Answer 5

Obwohl spät und schon einige gute Antworten vorhanden sind. Der Lösungsvorschlag von @Gilad hat den Schönheitsfehler, dass der zugewiesene Inhalt swim existiert als Typ, aber der Wert ist auf undefined . Eine robustere Prüfung wäre:

export const isFish= (pet: Fish | Bird): pet is Fish =>
   Object.keys(pet).includes('swim');

Diese Lösung wäre nicht abhängig vom Wert von swim ¡!