Why === instead of == for undefined

Question

Several sources suggest, that there are two canonical ways to check whether variable is undefined:

foo === undefined
typeof foo === 'undefined'

But can anyone explain, why would one use === instead of == ?

EDIT: the question is not about === vs ==. It is about using correct operator with the 'undefined'. The difference between === and == is obvious. But the question is which operator would be more correct when checking if value is undefined or not.

Answer 1

Sure simple. You base it off which behaviour you want (below)

null == undefined // true
undefined === null // false
typeof undefined // 'undefined'
typeof null // 'object'

Answer 2

=== is a strict comparison. === not only compares values but also datatype for example:

"2" == 2 is true
"2" === 2 is false

Answer 3

Looks like the question is not about the difference between == and === operators, but about in what situations one should use === undefined comparison and when typeof == 'unefined'. Well..

There are two ways to check for undefined value.

The first way is using strict comparison operator === to compare with undefined primitive:

var a;
a === undefined; // true

Above comparison will work as expected, only if the variable is declared but has undefined value. Note that if variable has never been declared you can't use a === undefined comparison because it will throw reference error:

a === undefined // ReferenceError: a is not defined 

That's why in this case typeof comparison is bullet-proof:

typeof a == 'undefined' // true

which will work properly in both cases: if variable has never been assigned a value, and if its value is actually undefined.

One more example. If we want to check for a prop property which is/can be missing:

someObj.prop === undefined // ReferenceError: a is not defined

but

typeof someObj.prop == 'undefined' // true

Answer 4

The === operator tests type as well as value. Using it consistently throughout your code helps to prevent a number of subtle and annoying errors, and is generally a Very Good Idea.

"5" == 5    // True, even though one is a string and the other a number
"5" === 5   // False because the two variables are of different type

While it's probably not strictly necessary when comparing to the special undefined property, it certainly doesn't hurt, and it's better to use === everywhere in your code than it would be to use === everywhere except for this corner case. Consistency is good.