instanceof keyword is a binary operator used to test if an object (instance) is a subtype of a given Type. Imagine: interface Domestic {} class Animal {} class Dog extends Animal implements Domestic {} class Cat extends Animal implements Domestic {} Imagine a dog object, created with Object dog = new Dog(), then: dog instanceof … Read more
TL;DR instanceof works with classes, not interfaces nor type aliases. What’s TypeScript trying to tell me? The issue is that instanceof is a construct from JavaScript, and in JavaScript, instanceof expects a value for the right-side operand. Specifically, in x instanceof Foo JavaScript will perform a runtime check to see whether Foo.prototype exists anywhere in … Read more
You can use instanceof operator: var t = /^foo(bar)?$/i; alert(t instanceof RegExp);//returns true In fact, that is almost the same as: var t = /^foo(bar)?$/i; alert(t.constructor == RegExp);//returns true Keep in mind that as RegExp is not a primitive data type, it is not possible to use typeof operator which could be the best option … Read more
Josh Bloch favors your approach: The reason that I favor the instanceof approach is that when you use the getClass approach, you have the restriction that objects are only equal to other objects of the same class, the same run time type. If you extend a class and add a couple of innocuous methods to … Read more
The instanceof-operator is called is in Dart. The spec isn’t exactly friendly to a casual reader, so the best description right now seems to be http://www.dartlang.org/articles/optional-types/. Here’s an example: class Foo { } main() { var foo = new Foo(); if (foo is Foo) { print(“it’s a foo!”); } }
Try using: if(NewType* v = dynamic_cast<NewType*>(old)) { // old was safely casted to NewType v->doSomething(); } This requires your compiler to have rtti support enabled. EDIT: I’ve had some good comments on this answer! Every time you need to use a dynamic_cast (or instanceof) you’d better ask yourself whether it’s a necessary thing. It’s generally … Read more
Enclose in parentheses and negate on the outside. if(!(obj instanceof Array)) { //… } In this case, the order of precedence is important. See: Operator Precedence. The ! operator precedes the instanceof operator.
Basically, you check if an object is an instance of a specific class. You normally use it, when you have a reference or parameter to an object that is of a super class or interface type and need to know whether the actual object has some other type (normally more concrete). Example: public void doSomething(Number … Read more
Primitives are a different kind of type than objects created from within Javascript. From the Mozilla API docs: var color1 = new String(“green”); color1 instanceof String; // returns true var color2 = “coral”; color2 instanceof String; // returns false (color2 is not a String object) I can’t find any way to construct primitive types with … Read more
This is a typical scenario where subtype polymorphism helps. Do the following interface I { void do(); } class A implements I { void do() { doA() } … } class B implements I { void do() { doB() } … } class C implements I { void do() { doC() } … } Then … Read more