The special number value NaN (see NaN) is not equal to itself:

> NaN === NaN
false

Thus, you need to use other means to check for it, which are described in Pitfall: checking whether a value is NaN.

A strict inequality comparison:

x !== y

is equivalent to the negation of a strict equality comparison:

!(x === y)

An inequality comparison:

x != y

is equivalent to the negation of an equality comparison:

!(x == y)

Step 3 means that equality and conversion to boolean (see Converting to Boolean) work differently. If converted to boolean, numbers greater than 1 become true (e.g., in if statements). But those numbers are not leniently equal to true. The comments explain how the results were computed:

> 2 == true  // 2 === 1
false
> 2 == false  // 2 === 0
false

> 1 == true  // 1 === 1
true
> 0 == false  // 0 === 0
true

Similarly, while the empty string is equal to false, not all nonempty strings are equal to true:

> '' == false   // 0 === 0
true
> '1' == true  // 1 === 1
true
> '2' == true  // 2 === 1
false
> 'abc' == true  // NaN === 1
false

Some of the leniency can be useful, depending on what you want:

> 'abc' == new String('abc')  // 'abc' == 'abc'
true
> '123' == 123  // 123 === 123
true

Other cases are problematic, due to how JavaScript converts strings to numbers (see Converting to Number):

> '\n\t123\r ' == 123  // usually not OK
true
> '' == 0  // 0 === 0
true

If you compare an object to a nonobject, it is converted to a primitive, which leads to strange results:

> {} == '[object Object]'
true
> ['123'] == 123
true
> [] == 0
true

However, two objects are only equal if they are they same object. That means that you can’t really compare two wrapper objects:

> new Boolean(true) === new Boolean(true)
false
> new Number(123) === new Number(123)
false
> new String('abc') == new String('abc')
false

The following comparison ensures that x is neither undefined nor null:

if (x != null) ...

While this is a compact way of writing this check, it confuses beginners, and experts can’t be sure whether it is a typo or not. Thus, if you want to check whether x has a value, use the standard check for truthiness (covered in Truthy and Falsy Values):

if (x) ...

If you want to be more precise, you should perform an explicit check for both values:

if (x !== undefined && x !== null) ...

If you are not sure whether a value x is a number or a number-as-a-string, you can use checks such as the following:

if (x == 123) ...

The preceding checks whether x is either 123 or '123'. Again, this is very compact, and again, it is better to be explicit:

if (Number(x) === 123) ...

Lenient equals lets you compare primitives with wrapped primitives:

> 'abc' == new String('abc')
true

There are three reasons against this approach. First, lenient equality does not work between wrapped primitives:

> new String('abc') == new String('abc')
false

Second, you should avoid wrappers anyway. Third, if you do use them, it is better to be explicit:

if (wrapped.valueOf() === 'abc') ...

Under ECMAScript 5, void is rarely useful. Its main use cases are:

According to JavaScript creator Brendan Eich, he added it to the language to help with javascript: links (one of the aforementioned use cases):

Unfortunately, typeof null is 'object'. This is considered a bug (null is not a member of the internal type Object), but it can’t be fixed, because doing so would break existing code. You thus have to be wary of null. For example, the following function checks whether value is an object:

function isObject(value) {
    return (value !== null
       && (typeof value === 'object'
           || typeof value === 'function'));
}

Trying it out:

> isObject(123)
false
> isObject(null)
false
> isObject({})
true

The first JavaScript engine represented JavaScript values as 32-bit words. The lowest 3 bits of such a word were used as a type tag, to indicate whether the value was an object, an integer, a double, a string, or a boolean (as you can see, even this early engine already stored numbers as integers if possible).

The type tag for objects was 000. In order to represent the value null, the engine used the machine language NULL pointer, a word where all bits are zero. typeof checked the type tag to determine the type of value, which is why it reported null to be an object.^[13]

The check:

typeof x === 'undefined'

has two use cases:

Here are examples of both use cases:

> var foo;
> typeof foo === 'undefined'
true

> typeof undeclaredVariable === 'undefined'
true

For the first use case, comparing directly with undefined is usually a better choice. However, it doesn’t work for the second use case:

> var foo;
> foo === undefined
true

> undeclaredVariable === undefined
ReferenceError: undeclaredVariable is not defined