# [ACCEPTED]-JavaScript equality transitivity is weird-transitivity

Score: 34
``````'' == '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.

yolpo (on falsy values)

Score: 8

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.

Score: 4

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**
``````

More Related questions