[ACCEPTED]-JavaScript equality transitivity is weird-transitivity

'' == '0' // false

The left hand side is an empty string, and 24 the right hand side is a string with one 23 character. They are false because it is 22 making a comparison between two un identical 21 strings (thanks Niall).

0 == '' // true

Hence, why this one is 20 true, because 0 is falsy and the empty string 19 is falsy.

0 == '0' // true

This one is a bit trickier. The spec 18 states that if the operands are a string 17 and a number, then coerce the string to 16 number. '0' becomes 0. Thanks smfoote.

false == undefined // false

The value undefined is 15 special in JavaScript and is not equal to 14 anything else except null. However, it is falsy.

false == null // false

Again, null is 13 special. It is only equal to undefined. It is also 12 falsy.

null == undefined // true

null and undefined are similar, but not the same. null means 11 nothing, whilst undefined is the value for a variable not 10 set or not existing. It would kind of make 9 sense that their values would be considered 8 equal.

If you want to be really confused, check 7 this...

'\n\r\t' == 0

A string consisting only of whitespace 6 is considered equal to 0.

Douglas Crockford 5 makes a lot of recommendations, but you 4 don't have to take them as gospel. :)

T.J. Crowder makes 3 an excellent suggestion of studying the 2 ECMAScript Language Specification to know the whole story behind these equality 1 tests.

Further Reading?

The spec.

yolpo (on falsy values)

The answer to this question has to do with 12 how JavaScript handles coercion. In the 11 case of ==, strings are coerced to be numbers. Therefore:

'' == '0' is equivalent to 10 '' === '0' (both are strings, so no coercion is necessary).

0 == '' is 9 equivalent to 0 === 0 because the string '' becomes 8 the number 0 (math.abs('') === 0).

0 == '0' is equivalent to 0 === 0 for the 7 same reason.

false == undefined is equivalent to 0 === undefined because JavaScript 6 coerces booleans to be numbers when types 5 don't match

false == null is equivalent to 0 === null for the same 4 reason.

null == undefined is true because the spec says so.

Thanks 3 for asking this question. My understanding 2 of == is much better for having researched 1 it.

You can actually write a JavaScript function 8 that behaves exactly like == that should give 7 you some insight into how it behaves.

To 6 show you what I mean here is that function:

// loseEqual() behaves just like `==`
function loseEqual(x, y) {
    // notice the function only uses "strict" operators 
    // like `===` and `!==` to do comparisons

    if(typeof y === typeof x) return y === x;

    if(typeof y === "function" || typeof x === "function") return false;

    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);

    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;

    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

As 5 you can see == has a lot of complicated logic 4 for type conversion. Because of that it's 3 hard to predict what result you are going 2 to get.

Here are some examples of some results 1 you wouldn't expect:

Unexpected Truths

[1] == true // returns true
'0' == false // returns true
[] == false // returns true
[[]] == false // returns true
[0] == false // returns true

'\r\n\t' == 0 // returns true

Unexpected Conclusions

// IF an empty string '' is equal to the number zero (0)
'' == 0 // return true

// AND the string zero '0' is equal to the number zero (0)
'0' == 0 // return true

// THEN an empty string must be equal to the string zero '0'
'' == '0' // returns **FALSE**

Objects with Special Functions

// Below are examples of objects that
// implement `valueOf()` and `toString()`

var objTest = {
    toString: function() {
        return "test";
    }
};

var obj100 = {
    valueOf: function() {
        return 100;
    }
};

var objTest100 = {
    toString: function() {
        return "test";
    },
    valueOf: function() {
        return 100;
    }
};

objTest == "test" // returns true
obj100 == 100 // returns true
objTest100 == 100 // returns true

objTest100 == "test" // returns **FALSE**