Why Is NaN Not Equal to Itself?

The earlier questions in this topic covered the basic types that JavaScript has and how the typeof operator reports them. This answer looks at the one special number value that behaves differently from every other value, and understanding it will save you from a very confusing bug.

The reason is that this value is not a number in the arithmetic sense at all. It comes from the IEEE 754 floating point standard, which defines a special result for operations that produce a meaningless answer. Dividing zero by zero does it, taking the square root of a negative number does it, and parsing a text value that contains no digits at all does it. The standard requires that this result is never equal to any value, including another copy of itself.

The reason behind that rule is soundness. If a failed calculation compared equal to itself, then a piece of code like if (result === expected) would pass when both sides were the result of a broken calculation, and the failure would be invisible. Making the value unequal to everything forces you to deal with it.

That design has one visible consequence. The standard way to test for it is the Number.isNaN function, and not the equality operators. The older global isNaN function is different and more dangerous. It converts its argument into a number first, so isNaN('hello') is true even though the text itself is not the special value, and isNaN(undefined) is also true. The static method only returns true for the actual special value.

There is a third comparison to know about as well. Object.is uses the SameValue algorithm, and under that algorithm the special value is equal to itself. That is why Object.is(NaN, NaN) is true while NaN === NaN is false. The stricter algorithm also tells a positive zero apart from a negative zero, where the strict operator treats them as the same value.

The previous answer explained why the not-a-number value is never equal to itself. This answer shows the correct way to test for it, because the wrong way is one of the most common mistakes in JavaScript code.

Use the Number.isNaN function. It takes a value, it does not convert anything, and it returns true only when the value really is the special not-a-number result.

console.log(NaN === NaN);              // false
console.log(NaN !== NaN);              // true
console.log(Number.isNaN(NaN));        // true
console.log(Number.isNaN('NaN'));      // false - text is not the special value
console.log(Number.isNaN(undefined));  // false

const values = [NaN, 1, '1', null];
for (const value of values) {
  console.log(String(value), Number.isNaN(value));
}

The difference between the static method and the older global function is the thing that interviewers ask about. The global isNaN converts its argument into a number before it tests, so it returns true for any text that cannot be read as a number, and that includes text that was never meant to be numeric in the first place. If you are checking user input, the global version is the wrong tool and it will surprise you. If you are checking the result of an arithmetic expression, the static method is exactly right.

There is also the self-inequality test, where you check whether a value is not equal to itself. It works and it is short, but it is hard to read, it breaks if a reader does not know the rule, and it is exactly the kind of cleverness that a lint rule will eventually flag for you.

For the opposite question, which is whether a value is a finite number, use Number.isFinite for the same reason. It does not convert anything, so it rejects text, and it also rejects infinity.