Back # isNaN

The

function determines whether a value is **isNaN()****NaN** or not. Note: coercion inside the `isNaN`

function has interesting rules; you may alternatively want to use **Number.isNaN()**, as defined in ECMAScript 6, or you can use `typeof`

to determine if the value is Not-A-Number.

`isNaN(`*testValue*)

`testValue`

- The value to be tested.

`isNaN`

functionUnlike all other possible values in JavaScript, it is not possible to rely on the equality operators (== and ===) to determine whether a value *is* **NaN** or not, because both `NaN == NaN`

and `NaN === NaN`

evaluate to `false`

. Hence, the necessity of an `isNaN`

function.

`NaN`

values`NaN`

values are generated when arithmetic operations result in *undefined* or *unrepresentable* values. Such values do not necessarily represent overflow conditions. A `NaN`

also results from attempted coercion to numeric values of non-numeric values for which no primitive numeric value is available.

For example, dividing zero by zero results in a `NaN`

— but dividing other numbers by zero does not.

Since the very earliest versions of the `isNaN`

function specification, its behavior for non-numeric arguments has been confusing. When the argument to the `isNaN`

function is not of type Number, the value is first coerced to a Number. The resulting value is then tested to determine whether it is **NaN**. Thus for non-numbers that when coerced to numeric type result in a valid non-NaN numeric value (notably the empty string and boolean primitives, which when coerced give numeric values zero or one), the "false" returned value may be unexpected; the empty string, for example, is surely "not a number." The confusion stems from the fact that the term, "not a number", has a specific meaning for numbers represented as IEEE-754 floating-point values. The function should be interpreted as answering the question, "is this value, when coerced to a numeric value, an IEEE-754 'Not A Number' value?"

The next version of ECMAScript (ES6) contains the **Number.isNaN()** function. `Number.isNaN(x)`

will be a reliable way to test whether `x`

is `NaN`

or not. Even with `Number.isNaN`

, however, the meaning of `NaN`

remains the precise numeric meaning, and not simply, "not a number". Alternatively, in absense of `Number.isNaN`

, the expression `(x != x)`

is a more reliable way to test whether variable `x`

is `NaN`

or not, as the result is not subject to the false positives that make `isNaN`

unreliable.

isNaN(NaN); // true isNaN(undefined); // true isNaN({}); // true isNaN(true); // false isNaN(null); // false isNaN(37); // false // strings isNaN("37"); // false: "37" is converted to the number 37 which is not NaN isNaN("37.37"); // false: "37.37" is converted to the number 37.37 which is not NaN isNaN(""); // false: the empty string is converted to 0 which is not NaN isNaN(" "); // false: a string with spaces is converted to 0 which is not NaN // dates isNaN(new Date()); // false isNaN(new Date().toString()); // true // This is a false positive and the reason why isNaN is not entirely reliable isNaN("blabla") // true: "blabla" is converted to a number. // Parsing this as a number fails and returns NaN

Created by Mozilla Contributors, license: CC-BY-SA 2.5