I've been reading Douglas Crockford's JavaScript: The Good Parts, and I came across this weird example that doesn't make sense to me:
'' == '0' // false
0 == '' // true
0 == '0' // true
false == undefined // false
false == null // false
null == undefined // true
The author also goes on to mention "to never use ==
and !=
. Instead, always use ===
and !==
". However, he doesn't explain why the above behavior is exhibited? So my question is, why are the above results as they are? Isn't transitivity considered in JavaScript?
You can actually write a JavaScript function that behaves exactly like
==
that should give you some insight into how it behaves.To show you what I mean here is that function:
As you can see
==
has a lot of complicated logic for type conversion. Because of that it's hard to predict what result you are going to get.Here are some examples of some results you wouldn't expect:
Unexpected Truths
Unexpected Conclusions
Objects with Special Functions
The answer to this question has to do with how JavaScript handles coercion. In the case of
==
, strings are coerced to be numbers. Therefore:'' == '0'
is equivalent to'' === '0'
(both are strings, so no coercion is necessary).0 == ''
is equivalent to0 === 0
because the string''
becomes the number0
(math.abs('') === 0
).0 == '0'
is equivalent to0 === 0
for the same reason.false == undefined
is equivalent to0 === undefined
because JavaScript coerces booleans to be numbers when types don't matchfalse == null
is equivalent to0 === null
for the same reason.null == undefined
is true because the spec says so.Thanks for asking this question. My understanding of
==
is much better for having researched it.The reason is that identity or strict operator (===), it compares with no type conversion, that means if both values doesn’t have the same value and the same type, they won’t be considered equal.
take a look this link, it takes you out of doubt: easy way to understand how identity operator works
The left hand side is an empty string, and the right hand side is a string with one character. They are false because it is making a comparison between two un identical strings (thanks Niall).
Hence, why this one is true, because
0
is falsy and the empty string is falsy.This one is a bit trickier. The spec states that if the operands are a string and a number, then coerce the string to number.
'0'
becomes0
. Thanks smfoote.The value
undefined
is special in JavaScript and is not equal to anything else exceptnull
. However, it is falsy.Again,
null
is special. It is only equal toundefined
. It is also falsy.null
andundefined
are similar, but not the same.null
means nothing, whilstundefined
is the value for a variable not set or not existing. It would kind of make sense that their values would be considered equal.If you want to be really confused, check this...
A string consisting only of whitespace is considered equal to 0.
Douglas Crockford makes a lot of recommendations, but you don't have to take them as gospel. :)
T.J. Crowder makes an excellent suggestion of studying the ECMAScript Language Specification to know the whole story behind these equality tests.
Further Reading?
The spec.
yolpo (on falsy values)