Why using the unary operator + on an array gives inconsistent results in javascript?

Question

I was doing some testing converting values to integer in javascript and printing the output in the console when I came across with this strange behavior.

console.log(+[]) ==> 0
console.log(+[123]) ==> 123
console.log(+['123']) ==> 123
console.log(+[123, 456]) ==> NaN
console.log(+['123asdf']) ==> NaN

I thought the values were being converted using parseInt but turns out it wasn't so I went to the javascript conversion table http://www.w3schools.com/js/js_type_conversion.asp

This give me a better idea on how conversions are performed. Acording to this table

[] => 0
[20] => 20
[10,20] => NaN
["twenty"] =>NaN
["ten","twenty"] => NaN

So aparently they take the first value of the array and convert it using the specified rules. The rules of parseInt does not apply.

I tested to reach this conclusion. You can nested it all you want, it will give you the same result.

console.log(+[[[[[[[[[[[10]]]]]]]]]]]) => 10

So then I thought, ok if that's the case

console.log(+[undefined]) will return NaN
console.log(+[null]) will return 0
console.log(+[false]) will return 0

those are the values expected from the javascript conversion table to integer but turns out

console.log(+[undefined]) => 0
console.log(+[null]) => 0
console.log(+[false]) => NaN

The last is the most strange because false is converted to 0, not to NaN. Can someone explain the strange behaviour or explain how this conversion is performed?

Answer 1

The Unary + operator internally uses the ToNumber abstract operation.

The ToNumber abstract operation, when applied to objects, calls the object's toString method (by way of the [[DefaultValue]] internal method) and then re-applies the ToNumber operation on the resulting string representation.

The interesting thing here is Array's toString method. Note that [false].toString() is quite different from [undefined].toString() or [null].toString(). When we inspect the specification for Array.prototype.toString, we see that internally it uses Array.prototype.join. Step 8 of the join algorithm says:

8. If element0 is undefined or null, let R be the empty String; otherwise, Let R be ToString(element0).

Thus, any array containing a single null or undefined stringifies to the empty string (which ToNumber number-ifies to 0), while other values will stringify to some other string (which will then number-ify to NaN if the string is non-numeric).

+[undefined] is the same as +"", while +[false] is the same as +"false".