Why does ",,," == Array(4) in Javascript?

Boot up your interpreter/console and try the comparison

> ",,," == Array(4)
True

Why? At first I thought maybe since you could think of ",,," as an array of four characters with a '\0' terminating slice, that might be why, but

> "..." == Array(4)

Returns "False". So... why? I know it's some idiosyncratic bit of duck typing in Javascript, but just curious what underlines this behavior. Gleaned this from Zed Shaw's excellent presentation here btw.

Because the right hand operand is converted to a string and the string representation of Array(4) is ,,,:

> Array(4).toString()
  ",,,"

If you use the array constructor function and pass a number, it sets the length of the array to that number. So you can say you have four empty indexes (same as [,,,]) and the default string representation of arrays is a comma-separated list of its elements:

> ['a','b','c'].toString()
  "a,b,c"

---

How the comparison works is described in section 11.9.3 of the specification. There you will see (x == y):

> 8. If Type(x) is either String or Number and Type(y) is Object,
return the result of the comparison x == ToPrimitive(y).

_{(arrays are objects in JavaScript)}

and if you follow the ToPrimitive method you will eventually find that it it calls toString.

Try using ===. When using == in Javascript, it will attempt to cast the variables, thus leading to issues like this one. The console is casting Array(4) to the string representation (i.e. Array(4).toString), which is ",,,". The reason the commas are there is that the .toString() function adds them to separate items in an array.

See the snippet below:

document.write( Array(4).toString() );

Internally its going

",,," == Array(4).toString()

This is because Array(4) initialises an array of 4 empty values, an == implicitly converts, so:

 ",,," == Array(4)

 ",,," == Array(4).toString()

 ",,," == ["", "", "", ""] // note 3 commas for 4 values

 ",,," == ["", "", "", ""].toString()

Are all similar.

== does implicit type conversions before comparing the values, which can result in unpredictable results. Use === to check the type and the value.

Comparing an Array to a string coerces the Array to a string before doing the comparison. Coercing an empty 4-element Array to a string yields that exact string.

I first thought it was something with the "prototype"... but after a little investigation I reached a sad conclusion...

Apparently it is an internal and more obscure js thing with not much logic...

Just try

Array(4)==Array(4)

and no coercion on types also...

Array(4)===Array(4)

and you'll get FALSE

you know that null==null, null===null and even undefined==undefined and undefined===undefined returns TRUE... so... it's a bit obscure...

Array(4)==[,,,] should be true also