Double Equals Comparison Operator in JavaScript

I’ve been doing a lot of development in JavaScript lately. I’ve found that evaluating values using the double equals comparison operator in JavaScript can produce some intriguing results.

First, I want to clarify the difference between double equals (==) and triple equals (===) in JavaScript. Double equals evaluates equality WITH type coercion while triple equals evaluates equality WITHOUT type coercion. Thus:

0 == false     //true
0 === false    //false

Double Equals (==)

Now for some more examples. For starters, when comparing '0' and '' to false, both evaluate to true:

'0' == false    //true
'' == false     //true

However, when we compare them against each other:

'0' == ''   //false

Interesting. Why is that? This is how the double equals works:

Equal (==)

If the two operands are not of the same type, JavaScript converts the operands then applies strict comparison. If either operand is a number or a boolean, the operands are converted to numbers if possible; else if either operand is a string, the other operand is converted to a string if possible. If both operands are objects, then JavaScript compares internal references which are equal when operands refer to the same object in memory (Comparison Operators, Mozilla Developer Network).

So, with the example at hand, JS evaluates the operand type first. Since neither operand is a number or boolean and at least one of the operands is a string, they are evaluated as strings. (In this case, just so happens both operands are strings.) Next JS evaluates the values, which are different. Despite the “falsey” nature of both zero and the empty string, as string types they are altogether different values and therefore not equal.

Let’s take a look at a couple other intriguing examples.

'' == '0'           // false
0 == ''             // true
0 == '0'            // true
false == 'false'    // false
false == '0'        // true
false == undefined  // false
false == null       // false
null == undefined   // true
' \t\r\n ' == 0     // true

To explain some of these examples that were perplexing to me the first time I examined them…

When comparing false == 'false', JS tries to convert both to numbers. The result is 0 === NaN, which is of course false. This also explains why false == '0' is true–because it boils down to 0 === 0.

It appears that when ' \t\r\n ' is converted to a number, JS converts it to 0. At any rate isNaN(' \t\r\n ') results in false, which tells me that when converted to a number, ' \t\r\n ' does NOT result in NaN. Therefore ' \t\r\n ' must boil down to 0 since ' \t\r\n ' == 0 is true.

For further reading and in depth analysis with helpful tables, I highly suggest reading Truth, Equality and JavaScript by Angus Croll.

Final Thoughts

Some developers avoid using == in their code because they don’t understand it and it’s confusing. I think it’s important to understand how == works since this will lead to language mastery. Furthermore, if you don’t use ==, your colleagues or 3rd party libraries will, and if you don’t understand it, then you are disempowered. After you understand ==, I see no problem with not using it. But simply avoiding it because it’s confusing and you don’t understand it seems unwise.

If you’re interested in the actual specification: Abstract Equality Comparison Algorithm

If performance is of concern when using == vs ===, these may be worth perusing:

More JavaScript


  1. […] JavaScript coerces the first operand and then evaluates the entire expression. The first operand coerces to true leaving true == '0' as the expression to be evaluated. Under this scenario, the types of each value are different and one of them is a boolean, so JavaScript tries to convert each to a number. This results in 1 === NaN, which is obviously false. For another look at how the double equals comparison operator works in JavaScript, read this blog post. […]


Comments, questions and feedback welcome.

This site uses Akismet to reduce spam. Learn how your comment data is processed.