Controllo del tipo di classe in TypeScript

In ActionScript è possibile verificare il tipo in fase di esecuzione utilizzando l' operatore is :

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

È possibile rilevare se una variabile (estende o) è una determinata classe o interfaccia con TypeScript?

Non ho trovato nulla al riguardo nelle specifiche della lingua. Dovrebbe essere lì quando si lavora con classi / interfacce.

4.19.4 L'istanza dell'operatore

L' instanceofoperatore richiede che l'operando di sinistra sia del tipo Any, un tipo di oggetto o un tipo di parametro di tipo e che l'operando di destra sia del tipo Any o di un sottotipo del tipo di interfaccia "Funzione". Il risultato è sempre del tipo primitivo booleano.

Quindi potresti usare

mySprite instanceof Sprite;

Nota che questo operatore è anche in ActionScript ma non dovrebbe più essere usato lì:

L'operatore is, che è nuovo per ActionScript 3.0, consente di verificare se una variabile o espressione è un membro di un determinato tipo di dati. Nelle versioni precedenti di ActionScript, l'operatore instanceof forniva questa funzionalità, ma in ActionScript 3.0 l'operatore instanceof non deve essere utilizzato per verificare l'appartenenza al tipo di dati. L'operatore is deve essere utilizzato al posto dell'operatore instanceof per il controllo manuale del tipo, poiché l'espressione x instanceof y controlla semplicemente la catena prototipo di x per l'esistenza di y (e in ActionScript 3.0, la catena prototipo non fornisce un quadro completo di la gerarchia ereditaria).

TypeScript instanceofcondivide gli stessi problemi. Dato che è una lingua ancora in fase di sviluppo, ti consiglio di dichiarare una proposta di questo tipo.

Guarda anche:

• MDN: instanceof

TypeScript ha un modo per convalidare il tipo di una variabile in fase di esecuzione. È possibile aggiungere una funzione di convalida che restituisce un predicato di tipo . Quindi puoi chiamare questa funzione all'interno di un'istruzione if ed essere sicuro che tutto il codice all'interno di quel blocco sia sicuro da usare come il tipo che pensi che sia.

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

Vedi di più su: https://www.typescriptlang.org/docs/handbook/advanced-types.html

È possibile utilizzare l' instanceofoperatore per questo. Da MDN:

L'operatore instanceof verifica se la proprietà prototipo di un costruttore appare in qualsiasi punto della catena prototipo di un oggetto.

Se non sai quali prototipi e catene di prototipi, ti consiglio vivamente di cercarlo. Anche qui c'è un esempio di JS (TS funziona in questo senso simile) che potrebbe chiarire il concetto:

    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 catena di prototipi in questo esempio è:

animal> Animal.prototype> Object.prototype