In ActionScript, it is possible to check the type at run-time using the is operator:
var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite); // true
trace(mySprite is DisplayObject);// true
trace(mySprite is IEventDispatcher); // true
Is it possible to detect if a variable (extends or) is a certain class or interface with TypeScript?
I couldn't find anything about it in the language specs. It should be there when working with classes/interfaces.
4.19.4 The instanceof operator
The
instanceofoperator requires the left operand to be of type Any, an object type, or a type parameter type, and the right operand to be of type Any or a subtype of the 'Function' interface type. The result is always of the Boolean primitive type.
So you could use
mySprite instanceof Sprite;
Note that this operator is also in ActionScript but it shouldn't be used there anymore:
The is operator, which is new for ActionScript 3.0, allows you to test whether a variable or expression is a member of a given data type. In previous versions of ActionScript, the instanceof operator provided this functionality, but in ActionScript 3.0 the instanceof operator should not be used to test for data type membership. The is operator should be used instead of the instanceof operator for manual type checking, because the expression x instanceof y merely checks the prototype chain of x for the existence of y (and in ActionScript 3.0, the prototype chain does not provide a complete picture of the inheritance hierarchy).
TypeScript's instanceof shares the same problems. As it is a language which is still in its development I recommend you to state a proposal of such facility.
See also:
instanceof Narrowing, which shows how instanceof can be used to narrow thingsTypeScript have a way of validating the type of a variable in runtime. You can add a validating function that returns a type predicate. So you can call this function inside an if statement, and be sure that all the code inside that block is safe to use as the type you think it is.
Example from the TypeScript docs:
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();
}
See more at: https://www.typescriptlang.org/docs/handbook/advanced-types.html
Std.is(pet, Fish), which works on types, interfaces etc.isFish itself is the predicate that is created, and its body doesn't have to be a one-liner predicate. The advantage of this is that the compiler understands at compile time the appropriate possible functions, but your code inside isFish is executed at runtime. You could even have the guard contain an instanceof statement, e.g. return pet instanceof Fish (assuming it's a class and not an interface), but this would be unnecessary since the compiler understands instanceof directly.
(pet as Fish) since the tslinter will complain about (<Fish>pet). See tslint docYou can use the instanceof operator for this. From MDN:
The instanceof operator tests whether the prototype property of a constructor appears anywhere in the prototype chain of an object.
If you don't know what prototypes and prototype chains are I highly recommend looking it up. Also here is a JS (TS works similar in this respect) example which might clarify the 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
The prototype chain in this example is:
animal > Animal.prototype > Object.prototype
You have two types of checks
by ex, the isString check can be performed like this:
function isString(value) {
return typeof value === 'string' || value instanceof String;
}
function isString(value): value is string { return typeof value === 'string' || value instanceof String; } const x: any = "im a string!"; if (isString(x)) console.log(x.toUpperCase()); Note that the return type is value is string.Although late and already some good answers exists. The proposed solution from @Gilad has the flaw if the assigned content swim exists as Type but the Value is set to undefined. A more robust check would be:
export const isFish= (pet: Fish | Bird): pet is Fish =>
'swim' in pet;
This solution wouldn't be dependent on the value of swim!
