Vérification du type de classe dans TypeScript

Dans ActionScript, il est possible de vérifier le type lors de l'exécution à l'aide de l' opérateur is :

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

Est-il possible de détecter si une variable (étend ou) est une certaine classe ou interface avec TypeScript?

Je n'ai rien trouvé à ce sujet dans les spécifications linguistiques. Il devrait être présent lorsque vous travaillez avec des classes / interfaces.

4.19.4 L'opérateur instanceof

L' instanceofopérateur requiert que l'opérande de gauche soit de type Any, un type d'objet ou un type de paramètre de type, et l'opérande de droite soit de type Any ou un sous-type de type d'interface «Fonction». Le résultat est toujours de type primitif booléen.

Vous pouvez donc utiliser

mySprite instanceof Sprite;

Notez que cet opérateur est également en ActionScript mais il ne devrait plus y être utilisé:

L'opérateur is, nouveau pour ActionScript 3.0, vous permet de tester si une variable ou une expression est membre d'un type de données donné. Dans les versions précédentes d'ActionScript, l'opérateur instanceof fournissait cette fonctionnalité, mais dans ActionScript 3.0, l'opérateur instanceof ne devait pas être utilisé pour tester l'appartenance au type de données. L'opérateur is doit être utilisé à la place de l'opérateur instanceof pour la vérification manuelle du type, car l'expression x instanceof y vérifie simplement la chaîne prototype de x pour l'existence de y (et dans ActionScript 3.0, la chaîne prototype ne fournit pas une image complète de la hiérarchie d'héritage).

TypeScript instanceofpartage les mêmes problèmes. Comme il s'agit d'une langue qui est encore en développement, je vous recommande de faire une proposition d'une telle facilité.

Voir également:

• MDN: instanceof

TypeScript a un moyen de valider le type d'une variable lors de l'exécution. Vous pouvez ajouter une fonction de validation qui renvoie un prédicat de type . Vous pouvez donc appeler cette fonction dans une instruction if, et assurez-vous que tout le code à l'intérieur de ce bloc est sûr à utiliser comme le type que vous pensez qu'il est.

Exemple tiré des documents TypeScript:

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();
}

Voir plus à: https://www.typescriptlang.org/docs/handbook/advanced-types.html

Vous pouvez utiliser l' instanceofopérateur pour cela. De MDN:

L'opérateur instanceof teste si la propriété prototype d'un constructeur apparaît n'importe où dans la chaîne de prototype d'un objet.

Si vous ne savez pas ce que sont les prototypes et les chaînes de prototypes, je vous recommande vivement de les rechercher. Voici également un exemple JS (TS fonctionne similaire à cet égard) qui pourrait clarifier le concept:

    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
    
    

La chaîne prototype dans cet exemple est:

animal> Animal.prototype> Object.prototype