Javascript array equal to zero but not itself

Question

I've been playing around with arrays in JavaScript and cannot figure out why this happens:

console.log(0 == 0)
//true

console.log([] == 0)
//true

console.log(0 == [])
//true

console.log([] == [])
//false

console.log([] == ![])
// true

The empty array is equal enough to zero both left and right, but why isn't it equal to itself?

I realise that comparing two objects would not result true, but why are they coerced to 0 (or falsy, which shouldn't be the case) if you compare them to 0, while threated as an object if you compare them to the other array?

Answer 1

console.log(0 == [])
//true 

You are trying to compare object with an integer, so your object is implicitly typecasted to equivalent integer value that is 0

console.log([] == [])
//false 

as two objects are never equal

Answer 2

console.log([] == [])

That will compare whether array1 and array2 are the same array object in memory, which is not what you want.

In order to do what you want, you'll need to check whether the two arrays have the same length, and that each member in each index is identical.

console.log([].length == [].length)
// true

Answer 3

Since the complete answer is never given and I actually understand it now, I'll provide the answer myself.

I found this in the Ecma-262 pdf:

It basically reads that [] == 0 is the same as Number([]) == 0 which is the same as 0 == 0 which is true. This does not apply to strict ===.

There is no rule to compare objects other then rule number one, which is x is the same as y. This means the same in everything, also memory address. Since they are not sharing the same memory address, rule 10 applies (return false).

The comparison x == y, where x and y are values, produces true or false. Such a comparison is performed as follows:

1. If Type(x) is the same as Type(y), then

   a. Return the result of performing Strict Equality Comparison x === y.

2. If x is null and y is undefined, return true.

3. If x is undefined and y is null, return true.
4. If Type(x) is Number and Type(y) is String, return the result of the comparison x == ToNumber(y).
5. If Type(x) is String and Type(y) is Number, return the result of the comparison ToNumber(x) == y.
6. If Type(x) is Boolean, return the result of the comparison ToNumber(x) == y.
7. If Type(y) is Boolean, return the result of the comparison x == ToNumber(y).
8. If Type(x) is either String, Number, or Symbol and Type(y) is Object, return the result of the comparison x == ToPrimitive(y).
9. If Type(x) is Object and Type(y) is either String, Number, or Symbol, return the result of the comparison ToPrimitive(x) == y.
10. Return false

Answer 4

This question is handled with the knowledge of object reference and type conversion more properly.First,in javascript, object value is stored by reference.So we can tell it is different from [] and [],because the two array correspond with two different addr in memory.Second, '==' is a not rigorous operation for both left and right, [] and 0 are both transformed to false.