JavaScript types

Question

As per http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf, JavaScript has 6 types: undefined, null, boolean, string, number and object.

var und;
console.log(typeof und); // <-- undefined

var n = null;
console.log(typeof n); // <--- **object**!

var b = true;
console.log(typeof b); // <-- boolean

var str = "myString"
console.log(typeof str); // <-- string

var int = 10;
console.log(typeof int); // <-- number

var obj = {}
console.log(typeof obj); // <-- object

Question 1:

Why is null of type object instead of null?

Question 2:

What about functions?

var f = function() {};
console.log(typeof f); // <-- function

Variable f has type of function. Why isn't it specified in the specification as a separate type?

Thanks,

Answer 1

About typeof null == 'object', this is a mistake that comes since the early days, and unfortunately this mistake will stay with us for a long time, it was too late to be fixed in the ECMAScript 5th Edition Specification.

About the functions, they are just objects, but they have an special internal property named [[Call]] which is used internally when a function is invoked.

The typeof operator distinguish between plain objects and functions just by checking if the object has this internal property.

Answer 2

It's because typeof is defined to return "object" if the input is null, and return "function" if the input is callable. (See 11.4.3 The typeof Operator.)

I don't know why the standard is defined like this (and Crockford said it's wrong). Maybe backward compatibility.

Answer 3

Answer to Question 1:

A property, when it has no definition, is undefined. The reason null is an Object is so that a property can exist with no value yet still have a definition.

Answer 4

typeof null === "object" because the spec says so, but this is a mistake from the very first version of JavaScript. (as KennyTM says above).

typeof f === "function" because, without a try/catch, there is no other reliable, foolproof way to determine if something is callable. Using f.constructor === Function might work, but I think it's not guaranteed to be so.

Answer 5

For completeness, note that the current best-practice way to check type information is something like this:

var typeInfo = Object.prototype.toString.call(yourObject);

That gives you a string that looks like "[object Something]", where "Something" is a type name.

Answer 6

null is a special value- it is not false, it is not 0, or the empty string or NaN or undefined.

null is what you get when you look for an object that is not there- not an undefined property of an object, but the thing itself.

a paragraph with one textNode will return null for the nodes nextSibling, a regexp that does'n match returns null instead of the array and so on.

maybe it should have its own type, but then it starts to be something, a something with a type, instead of the absence of an object.

Answer 7

There is also Array.prototype as well.

• Object.prototype
• Array.prototype
• Function.prototype
• Number.prototype
• String.prototype
• Boolean.prototype

Crockford says not to use:

• new Number()
• new String()
• new Boolean()