JavaScript: why `null == 0` is false?

Question

I had to write a routine that increments the value of a variable by 1 if it is a number, or assigns 0 to the variable if it is not a number. The variable can be incremented by the expression, or be assigned null. No other write access to the variable is allowed. So, the variable can be in three states: it is 0, a positive integer, or null.

My first implementation was: v >= 0 ? v += 1 : v = 0

(Yes, I admit that v === null ? v = 0 : v += 1 is the exact solution, but I wanted to be concise then.)

It failed since null >= 0 is true. I was confused, since if a value is not a number, an numeric expression involving it must be false always. Then I found that null is like 0, since null >= 0 && null <= 0 is true, null < 0 || null > 0 is false, null + 1 == 1, 1 / null == Infinity, Math.pow(2.718281828, null) == 1, ...

Strangely enough, however, null == 0 is evaluated to false. I guess null is the only value that makes the following expression false: (v == 0) === (v >= 0 && v <= 0)

So why null is so special in JavaScript?

Answer 1

null means no values whreas 0 is value itself.

Answer 2

null literally means nothing, the variable has no value at all where as 0 is a number, it is a value unlike null. Now because they are not same, null == 0 should be false naturally.

null            ==             0  // false
 ^                             ^
nothing/no value        a number/a value

Answer 3

Two ways to check if a value is 0 or null are:

1) The obvious if (val==null || val==0)

2) The more concise if (!val)

Answer 4

null is the absence of a value. 0 is a value.

Answer 5

alert(typeof null)

Answer 6

Your real question seem to be:

Why:

null >= 0; // true

But:

null == 0; // false

What really happens is that the Greater-than-or-equal Operator (>=), performs type coercion (ToPrimitive), with a hint type of Number, actually all the relational operators have this behavior.

You can see the inner details of this process in the The Abstract Relational Comparison Algorithm.

Edit: In response to your comment:

That's because null is treated in a special way by the Equals Operator (==).

In a brief, it only coerces to undefined:

null == null; // true
null == undefined; // true

All other values you mention are subject to numeric type coercion, all of them coerce to zero.

You can see the inner details of this process in the The Abstract Equality Comparison Algorithm.