Klastypecontrole in TypeScript

In ActionScript is het mogelijk om het type tijdens runtime te controleren met behulp van de is operator:

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

Is het mogelijk om te detecteren of een variabele (uitbreidt of) een bepaalde klasse of interface is met TypeScript?

Ik kon er niets over vinden in de taalspecificaties. Het zou er moeten zijn als je met klassen/interfaces werkt.

Antwoord 1, autoriteit 100%

4.19.4 De instanceof-operator

De operator instanceofvereist dat de linker operand van het type Any, een objecttype of een type parametertype is, en dat de rechter operand van het type Any of een subtype van de ‘Functie’ moet zijn interface-type. Het resultaat is altijd van het Booleaanse primitieve type.

Dus je zou kunnen gebruiken

mySprite instanceof Sprite;

Houd er rekening mee dat deze operator ook in ActionScript voorkomt, maar daar niet meer mag worden gebruikt:

Met de operator is, die nieuw is voor ActionScript 3.0, kunt u testen of een variabele of expressie lid is van een bepaald gegevenstype. In eerdere versies van ActionScript bood de operator instanceof deze functionaliteit, maar in ActionScript 3.0 mag de operator instanceof niet worden gebruikt om te testen op lidmaatschap van gegevenstypes. De operator is moet worden gebruikt in plaats van de operator instanceof voor handmatige typecontrole, omdat de expressie x instanceof y alleen de prototypeketen van x controleert op het bestaan van y (en in ActionScript 3.0 geeft de prototypeketen geen volledig beeld van de overervingshiërarchie).

TypeScript’s instanceofdeelt dezelfde problemen. Aangezien het een taal is die nog in ontwikkeling is, raad ik u aan om een voorstel voor een dergelijke faciliteit te doen.

Zie ook:

• MDN: instanceof

Antwoord 2, autoriteit 19%

TypeScript heeft een manier om het type van een variabele in runtime te valideren.
U kunt een validerende functie toevoegen die een type predikaatretourneert.
Je kunt deze functie dus in een if-statement aanroepen en er zeker van zijn dat alle code in dat blok veilig is om te gebruiken als het type dat je denkt dat het is.

Voorbeeld uit de TypeScript-documenten:

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

Bekijk meer op:
https://www.typescriptlang.org/docs/handbook/advanced-types.html

Antwoord 3, autoriteit 3%

U kunt hiervoor de operator instanceofgebruiken. Van MDN:

De operator instanceof test of de eigenschap prototype van a
constructor verschijnt overal in de prototypeketen van een object.

Als je niet weet wat prototypes en prototypeketens zijn, raad ik je ten zeerste aan om het op te zoeken. Hier is ook een JS-voorbeeld (TS werkt in dit opzicht vergelijkbaar) dat het concept zou kunnen verduidelijken:

   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