The isNaN()
function determines whether a value is 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
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
valuesNaN
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