Question

If you call Object.prototype.toString.call(anything) the result is always [object Something], where Something could be one of several things. My question is why is the “object” part there? It seems superfluous to always have it there. It doesn’t tell you anything about the argument which was passed in.

Object.prototype.toString.call(null);
=> [object Null]

Object.prototype.toString.call(undefined);
=> [object Undefined]

Since null and undefined aren’t objects (and fails CheckObjectCoercible), the “object” part really, really seems meaningless.

I have to think there was some reason originally that the “object” part was put there, even if the reason has been lost in the time since, and it’s now just preserved for historical reasons.

Can anyone help shed some light on this?

---

To be clear, I already know how Object.prototype.toString can be used to get the [[Class]] (type) of an object. My question concerns the reason for the format of the returned string — specifically the “object” part at the beginning. I want to know if there was ever a reason for this part or if there is a possible future reason for this part. Maybe in the future it could return something other than “object”? Can I expect it to always return “object”? If so, why does it even return it? Who wants a function to always return the same thing no matter what the input is?

Answer 1

Annex F of the ES5.1 specification says this about Object.prototype.toString:

15.2.4.2: Edition 5 handling of undefined and null as this value caused existing code to fail. Specification modified to maintain compatibility with such code. New steps 1 and 2 added to the algorithm.

This is a correction that was made in the ES5.1 spec. Prior to ES5, passing null or undefined to toString always caused the global object to be passed instead. Strict mode related changes in ES5 cause null and undefined to be passed without modification. As specified in ES5, passing null or undefined to Object.prototype.toString caused a TypeError exception. This exception broke some existing code so we had to fix the spec to not throw in that case.

So what should toString return for null and undefined? It turns out that a lot of existing code also expects Object.prototype.toString to always return a string of the form "[object *]". So, we decided to make null and undefined produce "[object Null]" and "[object Undefined]".

This seems to have worked and generally permitted existing ES3-based code to keep working in the presence of the strict mode related changes in ES5/5.1.