0

I have a basic understanding of instanceof in JavaScript, testing if the left hand side object "is of" the right hand side object type. The following 2 examples help me understand that...

var demo1 = function() {};
demo1.prototype = {
foo: "hello"
};

var demo2 = function() {
var pub = {
    bar:"world"
};
return this.pub;
};

var obj1 = new demo1();
var obj2 = new demo2();

console.log(obj1 instanceof demo1);  //returns true
console.log(obj2 instanceof demo2);  //returns true

But on this 3rd example, I get false and I don't understand why....

var o = {}; // new Object;
o.toString(); // [object Object]
console.log(o instanceof toString); //returns false

Thanks for any help in understanding whats going on. Also...is is possible to make the 3rd example true?

Thanks again

4
  • Your demo2 function is screwed up. There is no this.pub, so it will return undefined, and when called with the new operator this will result in an empty object (beeing an instanceof demo2 at least) Commented Oct 15, 2012 at 14:08
  • It returns true for me, I'm using an example based off of T.J. Crawford's blog here - blog.niftysnippets.org/2010/03/anonymouses-anonymous.html Commented Oct 15, 2012 at 14:12
  • 1
    Yes, obj2 instanceof demo2 is true for me, too. Still, your constructor is useless and could be replaced by an empty function. I can't see how yours came from any example in that very good article. Commented Oct 15, 2012 at 14:18
  • Bergi I didn't post example 2 as a best practice for patterns, I know that. It's based on a response from a blog comment on that article. That's all. I plan on using standard patterns to achieve my goals. Thanks for the heavy critique on staying away from the style mentioned above. And yes its a great article. Commented Oct 15, 2012 at 14:23

3 Answers 3

4

toString does not cause a type change of o. It just returns a string representation of the object, without altering it. So, o is still a simple object and no instanceof String.

var o = {}; // new Object object
var ostring = o.toString(); // "[object Object]"
typeof o; // object
typeof ostring; // string - this is a primitive value, not an object; so that
ostring instanceof String; // is false
var stringobj = new String(ostring); // new String object
typeof stringobj; // object
stringobj instanceof String; // true!
o instanceof Object; // also true!

See also MDN reference for the String constructor.

Sign up to request clarification or add additional context in comments.

Comments

1

o is an object; toString is a function. They are different types in JavaScript.

alert(typeof(o));  //"object"
alert(typeof(toString)); //"function"

JavaScript makes a distinction between objects and functions. Therefore, that's why you get false returned in your example.

2 Comments

obj2 is a object and demo2() is a function. I just tested it within my web console, and yet I get a "return true" with them. So there has to be more than what you are saying...
Check out this SO question - stackoverflow.com/questions/2449254/… . In the accepted answer, a variable on the LHS returns true if the object inherit's from the RHS's prototype. That's what you're doing in your obj2 = new demo2() statement. So obj2 inherits from demo2 prototype. Therefore, obj2 is an instance of demo2. o and toString aren't related by a common prototype, so the instanceof check returns false. I hope that helps.
1

With an object literal like

var o = {}; // new Object;

you create an object whose prototype is Object. Testing with instanceof will not yield any useful information. The only comparison that will yield true is

o instanceof Object

1 Comment

Thank you Ingo! That helps me to understand what I'm comparing things too now!

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.