Why is isNaN(null) == false in JS?
javascript
Solution
I believe the code is trying to ask, "is `x` numeric?" with the specific case here of `x = null`. The function `isNaN()` can be used to answer this question, but semantically it's referring specifically to the value `NaN`. From Wikipedia for `NaN`:
NaN (Not a Number) is a value of the numeric data type representing an undefined or unrepresentable value, especially in floating-point calculations.
In most cases we think the answer to "is null numeric?" should be no. However, `isNaN(null) == false` is semantically correct, because `null` is not `NaN`.
Here's the algorithmic explanation:
The function `isNaN(x)` attempts to convert the passed parameter to a number1 (equivalent to `Number(x)`) and then tests if the value is `NaN`. If the parameter can't be converted to a number, `Number(x)` will return `NaN`2. Therefore, if the conversion of parameter `x` to a number results in `NaN`, it returns true; otherwise, it returns false.
So in the specific case `x = null`, `null` is converted to the number 0, (try evaluating `Number(null)` and see that it returns 0,) and `isNaN(0)` returns false. A string that is only digits can be converted to a number and isNaN also returns false. A string (e.g. `'abcd'`) that cannot be converted to a number will cause `isNaN('abcd')` to return true, specifically because `Number('abcd')` returns `NaN`.
In addition to these apparent edge cases are the standard numerical reasons for returning NaN like 0/0.
As for the seemingly inconsistent tests for equality shown in the question, the behavior of `NaN` is specified such that any comparison `x == NaN` is false, regardless of the other operand, including `NaN` itself1.
Problem
This code in JS gives me a popup saying "i think null is a number", which I find slightly disturbing. What am I missing? ``` if (isNaN(null)) { alert("null is not a number"); } else { alert("i think null is a number"); } ``` I'm using Firefox 3. Is that a browser bug? Other tests: ``` console.log(null == NaN); // false console.log(isNaN("text")); // true console.log(NaN == "text"); // false ``` So, the problem seems not to be an exact comparison with NaN? Edit: Now the question has been answered, I have cleaned up my post to have a better version for the archive. However, this renders some comments and even some answers a little incomprehensible. Don't blame their authors. Among the things I changed was: - Removed a note saying that I had screwed up the headline in the first place by reverting its meaning - Earlier answers showed that I didn't state clearly enough why I thought the behaviour was weird, so I added the examples that check a string and do a manual comparison.