The value `NaN`

is a special quantity defined by
IEEE 754. It stands for *not a number*, even though:

typeof NaN === 'number' // true

The value can be produced by attempting to convert a string to a number when the string is not in the form of a number. For example:

+ '0' // 0 + 'oops' // NaN

If `NaN`

is an operand in an arithmetic
operation, then `NaN`

will be the result. So, if
you have a chain of formulas that produce `NaN`

as
a result, at least one of the inputs was `NaN`

, or
`NaN`

was generated somewhere.

You can test for `NaN`

. As we have seen, `typeof`

does not distinguish between numbers and
`NaN`

, and it turns out that `NaN`

is not equal to itself. So, surprisingly:

NaN === NaN // false NaN !== NaN // true

JavaScript provides an `isNaN`

function that can
distinguish between numbers and `NaN`

:

isNaN(NaN) // true isNaN(0) // false isNaN('oops') // true isNaN('0') // false

The `isFinite`

function is the best way of
determining whether a value can be used as a number because it rejects `NaN`

and `Infinity`

.
Unfortunately, `isFinite`

will attempt to convert
its operand to a number, so it is not a good test if a value is not actually a
number. You may want to define your own `isNumber`

function:

var isNumber = function isNumber(value) { return typeof value === 'number' && isFinite(value); };

Start Free Trial

No credit card required