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 code, perhaps it's not possible. This is probably why people use typeof "foo" === "string" instead of instanceof.
An easy way to remember things like this is asking yourself "I wonder what would be sane and easy to learn"? Whatever the answer is, Javascript does the other thing.
Answer from John Millikin on Stack Overflowjavascript - Why does instanceof return false for some literals? - Stack Overflow
What is the instanceof operator in JavaScript? - Stack Overflow
instanceof, why not?
instanceof is usually code smell. As in, there is probably a better way to achieve the same thing.
For numbers and strings, typeof is a good option. For functions, duck typing is often a better choice than instanceof. So your code might look like this:
if (typeof obj.dispose === 'function')
obj.dispose()
constructor is unreliable and can be overridden easily. You should never rely on it to be a particular value.
How does the "instanceof" operator work?
Videos
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 code, perhaps it's not possible. This is probably why people use typeof "foo" === "string" instead of instanceof.
An easy way to remember things like this is asking yourself "I wonder what would be sane and easy to learn"? Whatever the answer is, Javascript does the other thing.
I use:
function isString(s) {
return typeof(s) === 'string' || s instanceof String;
}
Because in JavaScript strings can be literals or objects.
instanceof
The Left Hand Side (LHS) operand is the actual object being tested to the Right Hand Side (RHS) operand which is the actual constructor of a class. The basic definition is:
Checks the current object and returns true if the object is of the specified object type.
Here are some good examples and here is an example taken directly from Mozilla's developer site:
var color1 = new String("green");
color1 instanceof String; // returns true
var color2 = "coral"; //no type specified
color2 instanceof String; // returns false (color2 is not a String object)
One thing worth mentioning is instanceof evaluates to true if the object inherits from the class's prototype:
var p = new Person("Jon");
p instanceof Person
That is p instanceof Person is true since p inherits from Person.prototype.
Per the OP's request
I've added a small example with some sample code and an explanation.When you declare a variable you give it a specific type.
For instance:
int i;
float f;
Customer c;
The above show you some variables, namely i, f, and c. The types are integer, float and a user defined Customer data type. Types such as the above could be for any language, not just JavaScript. However, with JavaScript when you declare a variable you don't explicitly define a type, var x, x could be a number / string / a user defined data type. So what instanceof does is it checks the object to see if it is of the type specified so from above taking the Customer object we could do:
var c = new Customer();
c instanceof Customer; //Returns true as c is just a customer
c instanceof String; //Returns false as c is not a string, it's a customer silly!
Above we've seen that c was declared with the type Customer. We've new'd it and checked whether it is of type Customer or not. Sure is, it returns true. Then still using the Customer object we check if it is a String. Nope, definitely not a String we newed a Customer object not a String object. In this case, it returns false.
It really is that simple!
There's an important facet to instanceof that does not seem to be covered in any of the comments thus far: inheritance. A variable being evaluated by use of instanceof could return true for multiple "types" due to prototypal inheritance.
For example, let's define a type and a subtype:
function Foo(){ //a Foo constructor
//assign some props
return this;
}
function SubFoo(){ //a SubFoo constructor
Foo.call( this ); //inherit static props
//assign some new props
return this;
}
SubFoo.prototype = Object.create(Foo.prototype); // Inherit prototype
SubFoo.prototype.constructor = SubFoo;
Now that we have a couple of "classes" lets make some instances, and find out what they're instances of:
var
foo = new Foo()
, subfoo = new SubFoo()
;
alert(
"Q: Is foo an instance of Foo? "
+ "A: " + ( foo instanceof Foo )
); // -> true
alert(
"Q: Is foo an instance of SubFoo? "
+ "A: " + ( foo instanceof SubFoo )
); // -> false
alert(
"Q: Is subfoo an instance of Foo? "
+ "A: " + ( subfoo instanceof Foo )
); // -> true
alert(
"Q: Is subfoo an instance of SubFoo? "
+ "A: " + ( subfoo instanceof SubFoo )
); // -> true
alert(
"Q: Is subfoo an instance of Object? "
+ "A: " + ( subfoo instanceof Object )
); // -> true
See that last line? All "new" calls to a function return an object that inherits from Object. This holds true even when using object creation shorthand:
alert(
"Q: Is {} an instance of Object? "
+ "A: " + ( {} instanceof Object )
); // -> true
And what about the "class" definitions themselves? What are they instances of?
alert(
"Q: Is Foo an instance of Object? "
+ "A:" + ( Foo instanceof Object)
); // -> true
alert(
"Q: Is Foo an instance of Function? "
+ "A:" + ( Foo instanceof Function)
); // -> true
I feel that understanding that any object can be an instance of MULTIPLE types is important, since you may (incorrectly) assume that you could differentiate between, say an object and a function by use of instanceof. As this last example clearly shows a function is an object.
This is also important if you are using any inheritance patterns and want to confirm the progeny of an object by methods other than duck-typing.
Good night reddit,
I have been developing Javascript for over 2 years now and just recently learn the advantages of using 'instanceof'.
Since then, I find myself using "(function(){}) instanceof Function" and not "typeof" because I don't like string comparison at such low level.
And it seems really reliable except for primitives types...
For which i use (5).constructor === Number or ("").constructor === String.
I guess I really hate typeof :P
I know this probably won't give any performance boost, but is there a reason for not using it? Maybe some sort IE bug from 2003? I found only a few articles that did not advise against it, but the lack of knowledge of it irks me.
instanceof is usually code smell. As in, there is probably a better way to achieve the same thing.
For numbers and strings, typeof is a good option. For functions, duck typing is often a better choice than instanceof. So your code might look like this:
if (typeof obj.dispose === 'function')
obj.dispose()
constructor is unreliable and can be overridden easily. You should never rely on it to be a particular value.
If you're doing this a lot, it might be better to grab a module to handle this for you. I wrote a very small one that does just that; it's based on Object.prototype.toString.
That said, there are definitely times when you might really want "instanceof". Specifically, when creating classes and subclasses. Here's some code that shows what I'm talking about
http://jsfiddle.net/8m8fb6z0/
EDIT: to be clear, 'instanceof' traverses up an object's prototype chain looking for a match, whereas the behavior of 'typeof' is essentially a hardcoded language feature
Edit: I know that instanceof checks at runtime, I'm very familiar with it and have been using it for many years. My question is specifically how the typing system works in typescript, how/why typescript is able to discern via type inference the difference between Error and PseudoError. And, given that it can, whether it is possible to leverage that kind of discernment to create a utility function that's based on this rather than based on shapes and interfaces.
In lib.es5.d.ts in typescript we have:
interface Error {
name: string;
message: string;
stack?: string;
}Now in my typescript file, if I create a new type, like this:
class PseudoError {
name = "hello"
message = "world"
stack? = "friends"
}And I do the following:
const test : PseudoError | Error = new PseudoError() type withoutError = Exclude<typeof test, Error> // <--- results to never, because of duck typing ?
The above is expected, because PseudoError and Error implement the same interface. So if I'm excluding Error, then I'm also excluding PseudoError by duck type standards.
But when I do this:
if (test instanceof Error) {
test // <--- hover over = Error
} else {
test // <--- hover over = PseudoError
}
It suggests that there is obviously some built-in functionality in typescript that doesn't work like in a duck-type-y way. This clearly aligns with the desired outcome in JS, but in my situation, I would like to have an Exclude<...> utility type that does the same thing as what typescript is doing behind the scenes with instanceof.
For example, where's this NotInstanceOf utility function?
const test : PseudoError | Error = new PseudoError() type withoutError = NotInstanceOf<typeof test, Error> // <--- results to PsuedoError