NaN
The NaN
global property is a value representing Not-A-Number.
Try it
Value
The same number value as Number.NaN
.
Property attributes of NaN |
|
---|---|
Writable | no |
Enumerable | no |
Configurable | no |
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 meansNaN
is 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
NaN
is involved in a mathematical operation (but not bitwise operations), the result is usually alsoNaN
. (See counter-example below.) - When
NaN
is one of the operands of any relational comparison (>
,<
,>=
,<=
), the result is alwaysfalse
. NaN
compares unequal (via==
,!=
,===
, and!==
) to any other value — including to anotherNaN
value.
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
.
js
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
:
js
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()
:
js
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:
js
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.
js
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.
js
NaN ** 0 === 1; // true
Specifications
Specification |
---|
ECMAScript Language Specification # sec-value-properties-of-the-global-object-nan |
Browser compatibility
BCD tables only load in the browser