# Why `NaN` !== NaN

Among the many seeming oddities of JavaScript is the fact that `NaN` (Not-a-Number) is not equal to itself. Countless beginners have written conditionals checking if `n === NaN`, only to find that this is never true. The solution, of course, is to use the built-in checker, `Number.isNaN()`. Confusion over this inequality often boils over to agitation and unfair condescension at the JavaScript language.

I’m here to tell you that `NaN !== NaN `is a feature of JavaScript and not a bug.

Why shouldn’t `NaN` be equal to itself? Because that would lead to bad comparisons. `NaN` is coalescing, meaning that any mathematical operation done with `NaN` results in `NaN`. If two complex calculations were done and then their results compared, you would expect them to be equal if and only if they yielded the same number. Suppose there was an error in the calculations or in the input value and they each resulted in `NaN`. They should not be considered equal here because not all failures are equal.

`function avg(num1, num2) {  return (num1 + num2) / 2;}// both are NaN and SHOULD NOT be equalavg('1.2', '2.2') === avg('1.3', '2.3')`

If bad calculations returned `null` or `undefined` instead of `NaN`, then false equivalences would abound.

Why is `NaN` a Number type? You might expect something called Not-a-Number to not be a number, but `typeof NaN === "number"`. This is needed in order for `NaN` to work the way it does. It has to inherit from the Number prototype so that any mathematical operations performed with it do not throw errors.

A variable holding a number or possibly a `NaN` can still have `toPrecision()` called on it. If `NaN` weren’t a Number type, you would have to check for it before doing any and every mathematical operation. That would get tedious! Yet another reason that bad calculations in JavaScript return `NaN` instead of `null` or `undefined`.

Keep these reasons in mind the next time you write a function that returns a number. You may wish to return `NaN` for the “bad paths” of the function, rather than something else.

Note that there are two `isNaN()` methods in JavaScript: the global one and the one in the `Number` object. There’s a subtle but significant difference in them. The global `isNaN()` method coerces its argument into a number first, meaning that `undefined`, `{}`, `'NaN'`, and many other inputs return true. (This means `isNaN(undefined) === true`, even though `undefined` is clearly not `NaN`.)

`Number.isNaN()`, however, does not coerce its argument. It will return true if and only if its argument is actually `NaN`. This is probably the method you want to use. It is a newer addition to ECMAScript (the JavaScript specification) and it is supported in every browser except Internet Explorer. Fortunately, writing your own polyfill is easy since `NaN` is the only value not equal to itself:

`function isNaN(n) {  return n !== n;}`

Web Developer, Oregonian, husband