The NaN global property is a value representing Not-A-Number.
Value
The same number value as Number.NaN.
Description
NaN is a property of the global object. In other words, it is a variable in global scope.
In modern browsers, NaN is a non-configurable, non-writable property. Even when this is not the case, avoid overriding it.
There are five different types of operations that return NaN:
- Failed number conversion (e.g. explicit ones like
parseInt("blabla"),Number(undefined), or implicit ones likeMath.abs(undefined)) - Math operation where the result is not a real number (e.g.
Math.sqrt(-1)) - Indeterminate form (e.g.
0 * Infinity,1 ** Infinity,Infinity / Infinity,Infinity - Infinity) - A method or expression whose operand is or gets coerced to
NaN(e.g.7 ** NaN,7 * "blabla") — this meansNaNis contagious - Other cases where an invalid value is to be represented as a number (e.g. an invalid Date
new Date("blabla").getTime(),"".charCodeAt(1))
NaN and its behaviors are not invented by JavaScript. Its semantics in floating point arithmetic (including that NaN !== NaN) are specified by IEEE 754. NaN's behaviors include:
- If
NaNis involved in a mathematical operation (but not bitwise operations), the result is usually alsoNaN. (See counter-example below.) - When
NaNis one of the operands of any relational comparison (>,<,>=,<=), the result is alwaysfalse. NaNcompares unequal (via==,!=,===, and!==) to any other value — including to anotherNaNvalue.
NaN is also one of the falsy values in JavaScript.
Examples
Testing against NaN
To tell if a value is NaN, use Number.isNaN or isNaN() to most clearly determine whether a value is NaN — or, since NaN is the only value that compares unequal to itself, you can perform a self-comparison like x !== x.
NaN === NaN; // false
Number.NaN === NaN; // false
isNaN(NaN); // true
isNaN(Number.NaN); // true
Number.isNaN(NaN); // true
function valueIsNaN(v) {
return v !== v;
}
valueIsNaN(1); // false
valueIsNaN(NaN); // true
valueIsNaN(Number.NaN); // true
However, do note the difference between isNaN() and Number.isNaN(): the former will return true if the value is currently NaN, or if it is going to be NaN after it is coerced to a number, while the latter will return true only if the value is currently NaN:
isNaN("hello world"); // true
Number.isNaN("hello world"); // false
For the same reason, using a BigInt value will throw an error with isNaN() and not with Number.isNaN():
isNaN(1n); // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN(1n); // false
Additionally, some array methods cannot find NaN, while others can. Namely, the index-finding ones (indexOf(), lastIndexOf()) cannot find NaN, while the value-finding ones (includes()) can:
const arr = [2, 4, NaN, 12];
arr.indexOf(NaN); // -1
arr.includes(NaN); // true
// Methods accepting a properly defined predicate can always find NaN
arr.findIndex((n) => Number.isNaN(n)); // 2
For more information about NaN and its comparison, see Equality comparison and sameness.
Observably distinct NaN values
There's a motivation for NaN being unequal to itself. It's possible to produce two floating point numbers with different binary representations but are both NaN, because in IEEE 754 encoding, any floating point number with exponent 0x7ff and a non-zero mantissa is NaN. In JavaScript, you can do bit-level manipulation using typed arrays.
const f2b = (x) => new Uint8Array(new Float64Array([x]).buffer);
const b2f = (x) => new Float64Array(x.buffer)[0];
// Get a byte representation of NaN
const n = f2b(NaN);
// Change the first bit, which is the sign bit and doesn't matter for NaN
n[0] = 1;
const nan2 = b2f(n);
console.log(nan2); // NaN
console.log(Object.is(nan2, NaN)); // true
console.log(f2b(NaN)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 127]
console.log(f2b(nan2)); // Uint8Array(8) [1, 0, 0, 0, 0, 0, 248, 127]
Silently escaping NaN
NaN propagates through mathematical operations, so it's usually sufficient to test for NaN once at the end of calculation to detect error conditions. The only case where NaN gets silently escaped is when using exponentiation with an exponent of 0, which immediately returns 1 without testing the base's value.
NaN ** 0 === 1; // true