NaN

Глобальное свойство NaN представляет собой значение Not-A-Number (Не число).

Попробуйте

function sanitize(x) {
  if (isNaN(x)) {
    return NaN;
  }
  return x;
}

console.log(sanitize("1"));
// Expected output: "1"

console.log(sanitize("NotANumber"));
// Expected output: NaN

Значение

То же числовое значение, что и у Number.NaN.

Описание

NaN — это свойство глобального объекта. Другими словами, это переменная в глобальной области видимости.

В современных браузерах NaN является не настраиваемым и не записываемым свойством. Даже если это не так, избегайте его переопределения.

Существует пять различных типов операций, которые возвращают NaN:

• Ошибка преобразования числа (например, явные, такие как parseInt("blabla"), Number(undefined), или неявные, такие как Math.abs(undefined))
• Математическая операция, результат которой не является действительным числом (например, Math.sqrt(-1))
• Неопределённая форма (например, 0 * Infinity, 1 ** Infinity, Infinity / Infinity, Infinity - Infinity)
• Метод или выражение, операнд которого является NaN или преобразуется к нему (например, 7 ** NaN, 7 * "blabla") — это означает, что NaN заразителен
• Другие случаи, когда недействительное значение должно быть представлено как число (например, недопустимое Date new Date("blabla").getTime(), "".charCodeAt(1))

NaN и его поведение не были изобретены JavaScript. Его семантика в арифметике с плавающей запятой (включая тот факт, что NaN !== NaN) специфицированы стандартом IEEE 754. Поведение NaN включает:

• Если NaN участвует в математической операции (но не в побитовых операциях), результат обычно также является NaN. (См. контрпример ниже.)
• Когда NaN является одним из операндов любого реляционного сравнения (>, <, >=, <=), результат всегда false.
• NaN сравнивается неравно (через ==, !=, === и !==) с любым другим значением — включая другое значение NaN.

NaN также является одним из falsy значений в JavaScript.

Примеры

Тестирование на NaN

Чтобы определить, является ли значение NaN, используйте Number.isNaN() или isNaN(), чтобы наиболее точно определить, является ли значение NaN — или, поскольку NaN является единственным значением, которое сравнивается неравно само с собой, вы можете выполнить самосравнение, например 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

Однако обратите внимание на разницу между isNaN() и Number.isNaN(): первая вернёт true, если значение в данный момент является NaN, или если оно будет NaN после преобразования в число, в то время как вторая вернёт true только в том случае, если значение в данный момент является NaN:

isNaN("hello world"); // true
Number.isNaN("hello world"); // false

По той же причине использование значения BigInt вызовет ошибку с isNaN() и не с Number.isNaN():

isNaN(1n); // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN(1n); // false

Кроме того, некоторые методы массива не могут найти NaN, в то время как другие могут. А именно, методы поиска индекса (indexOf(), lastIndexOf()) не могут найти NaN, в то время как методы поиска значения (includes()) могут:

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

Для получения дополнительной информации о NaN и его сравнении см. Сравнение равенства и идентичность.

Наблюдаемо различные значения NaN

Возможно получить два числа с плавающей запятой с различными двоичными представлениями, но оба являются NaN, поскольку в кодировке IEEE 754 любое число с плавающей запятой с экспонентой 0x7ff и ненулевой мантиссой является NaN. В JavaScript вы можете выполнять побитовые манипуляции с помощью типизированных массивов.

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);
const m = f2b(NaN);
// Change the sign bit, which doesn't matter for NaN
n[7] += 2 ** 7;
// n[0] += 2**7; for big endian processors
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) [0, 0, 0, 0, 0, 0, 248, 255]
// Change the first bit, which is the least significant bit of the mantissa and doesn't matter for NaN
m[0] = 1;
// m[7] = 1; for big endian processors
const nan3 = b2f(m);
console.log(nan3); // NaN
console.log(Object.is(nan3, NaN)); // true
console.log(f2b(NaN)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 127]
console.log(f2b(nan3)); // Uint8Array(8) [1, 0, 0, 0, 0, 0, 248, 127]

Тихое обхождение NaN

NaN распространяется через математические операции, поэтому обычно достаточно проверить NaN один раз в конце вычисления, чтобы обнаружить условия ошибки. Единственный случай, когда NaN тихо обходится, — это при использовании возведения в степень с экспонентой 0, что немедленно возвращает 1 без проверки значения основания.

NaN ** 0 === 1; // true

Спецификации

Совместимость с браузерами

См. также

• Number.NaN
• Number.isNaN()
• isNaN()