Javascript array to boolean type coercion not making sense

Question

When I run the following line of code:

var x = []; console.log(!x); console.log(x == false);
> false
> true

I assumed using ! would coerce the type correctly similar to how it works in PHP, and that these two console logs would return the same output. Can someone explain to me what is going on here?

I am aware of the difference between === and ==. The point I'm trying to illustrate here is that using ! is not coercing the type to boolean correctly. I would expect the above two outputs to be the same. — ThinkingInBits, Feb 19 '15 at 02:07
@Frank refer to my comment in the first answer. I made a typo. Edited the question with the proper output. — ThinkingInBits, Feb 19 '15 at 02:09
Ah, sorry, I hadn't refreshed the page in time to see the edit. — Frank, Feb 19 '15 at 02:10
Actually, I think your code works just fine! You defined array, it exists, so it's "true". !x should return false. — Frank, Feb 19 '15 at 02:17
**exact** duplicate of [JavaScript type casting](http://stackoverflow.com/questions/4626361/javascript-type-casting) — Qantas 94 Heavy, Feb 19 '15 at 02:55

score 2 · Accepted Answer · edited May 23 '17 at 12:22

tl;dr: Converting a value to Boolean is very different from comparing a value to Boolean because JavaScript has implicit type conversion.

Can someone explain to me what is going on here?

!x is the same as doing !Boolean(x), i.e. x is explicitly converted to a Boolean.

With loose comparison, things are a little more evolved:

If the two operands are not of the same data type, JS will convert both of them to the same type. However, if any of the operands is a Boolean, that value is converted to a number, independently of the value of the other operand. That in turn means that the other operand is converted to a number as well.
So [] == false is the same as Number([]) == Number(false).

The algorithm for loose comparison can be found in the ECMAScript spec.

See also Why does {} == false evaluate to false while [] == false evaluates to true?, where I listed the conversion steps.

I assumed using ! would coerce the type correctly similar to how it works in PHP.

While there are certainly some similarities, the type conversion rules are complete independent.

Opinionated advice: This is a good example of why implicit type conversion should be avoided if possible.

Wait a second, I think your first statement about !x being the same as Boolean(x). !emptyArray returns a different output than Boolean(emptyArray) — ThinkingInBits, Feb 19 '15 at 02:30
I have to add also, that this is a great answer. You describe it better than any of the articles I could find on google. — ThinkingInBits, Feb 19 '15 at 05:26

score 1 · Answer 2 · answered Feb 19 '15 at 02:03

1

Actually, I think that it does work the way you think:

var x = [];

document.writeln(!x);
document.writeln(x == false);

answered Feb 19 '15 at 02:03

Ian Hazzard

7,661
7
34
60

I made a typo originally. My question is really, why would those two outputs be any different? – ThinkingInBits Feb 19 '15 at 02:05

score 1 · Answer 3 · answered Feb 19 '15 at 02:47

1

Okay, so I think I found the problem:

var x=[];
alert(x==false);// true;
x=[1];
alert(x==false);// false;

Even though x is defined, it does not return true unless it has content.

answered Feb 19 '15 at 02:47

Frank

2,050
6
22
40

Once again, I give input after the fact. Still, sometimes it's good to see the code in action, so I'll leave it up. – Frank Feb 19 '15 at 02:49

Javascript array to boolean type coercion not making sense

3 Answers3