Как в JavaScript проверить что число является NaN?

Как в JavaScript проверить что число является NaN?

NaN (Not-a-Number) — это специальное значение в JavaScript, которое представляет результат невалидной или неопределённой численной операции. Проверка на NaN может быть хитрой, так как NaN имеет необычное поведение.

Главная особенность NaN

NaN - это единственное значение в JavaScript, которое не равно самому себе:

NaN === NaN // false
NaN == NaN  // false

Это означает, что простое сравнение x === NaN не работает!

Способ 1: Number.isNaN() - рекомендуется

Это самый надежный и современный способ:

Number.isNaN(NaN);        // true
Number.isNaN(123);        // false
Number.isNaN('hello');    // false (важно!)
Number.isNaN(undefined);  // false
Number.isNaN({});         // false

// Пример
const result = 0 / 0; // NaN
if (Number.isNaN(result)) {
  console.log('Результат невалиден');
}

Преимущество: не приводит значения к числу, проверяет строго.

Способ 2: isNaN() - не рекомендуется

Глобальная функция isNaN() имеет неправильное поведение - она приводит значение к числу перед проверкой:

isNaN(NaN);        // true
isNaN(123);        // false
isNaN('hello');    // true (опасно!) - "hello" приводится к NaN
isNaN('123');      // false - "123" приводится к 123
isNaN(undefined);  // true - приводится к NaN
isNaN({});         // true

Проблема:

// Ожидаем false, но получаем true!
isNaN('это не число'); // true
isNaN(null);           // false (null приводится к 0)

Способ 3: Проверка через Object.is()

Можно использовать Object.is(), который правильно работает с NaN:

Object.is(NaN, NaN);  // true
Object.is(123, NaN);  // false
Object.is(NaN, 0);    // false

// Пример функции
function checkNaN(value) {
  return Object.is(value, NaN);
}

checkNaN(NaN);  // true
checkNaN(123);  // false

Способ 4: Сравнение с самим собой

Используем факт, что NaN не равна самому себе:

function checkNaN(value) {
  return value !== value;
}

checkNaN(NaN);     // true
checkNaN(123);     // false
checkNaN('hello'); // false

Минус: это не очень понятный и хаков способ, не рекомендуется в production коде.

Способ 5: Использование Number.prototype.valueOf()

function checkNaN(value) {
  return typeof value === 'number' && isNaN(value);
}

checkNaN(NaN);       // true
checkNaN(123);       // false
checkNaN('hello');   // false
checkNaN(undefined); // false

Это комбинация проверки типа и функции isNaN() - работает надежно.

Различие между Number.isNaN() и isNaN()

Таблица сравнения:

const testCases = [NaN, 123, '123', 'hello', undefined, null, {}];

testCases.forEach(value => {
  console.log(
    `${String(value).padEnd(10)} | Number.isNaN: ${Number.isNaN(value).toString().padEnd(5)} | isNaN: ${isNaN(value)}`
  );
});

// Результат:
// NaN        | Number.isNaN: true  | isNaN: true
// 123        | Number.isNaN: false | isNaN: false
// 123        | Number.isNaN: false | isNaN: false
// hello      | Number.isNaN: false | isNaN: true
// undefined  | Number.isNaN: false | isNaN: true
// null       | Number.isNaN: false | isNaN: false
// [object]   | Number.isNaN: false | isNaN: true

Практические примеры

1. Валидация пользовательского ввода

function validateNumber(input) {
  const num = parseFloat(input);
  
  if (Number.isNaN(num)) {
    return { valid: false, error: 'Введите валидное число' };
  }
  
  return { valid: true, value: num };
}

validateNumber('123');    // { valid: true, value: 123 }
validateNumber('не число'); // { valid: false, error: 'Введите валидное число' }
validateNumber('');       // { valid: false, error: 'Введите валидное число' }

2. Безопасная работа с результатами вычислений

function divide(a, b) {
  const result = a / b;
  
  if (Number.isNaN(result)) {
    throw new Error('Невозможно выполнить операцию');
  }
  
  return result;
}

divide(10, 2);  // 5
divide(0, 0);   // ошибка: NaN

3. Фильтрация массива чисел

const values = [1, NaN, 2, NaN, 3, 4, NaN];

// Убираем NaN
const validNumbers = values.filter(v => !Number.isNaN(v));
console.log(validNumbers); // [1, 2, 3, 4]

4. Проверка в условиях

const userAge = parseInt(userInput);

if (Number.isNaN(userAge) || userAge < 0 || userAge > 150) {
  console.log('Некорректный возраст');
} else {
  console.log(`Ваш возраст: ${userAge}`);
}

Когда появляется NaN?

// Математические операции
0 / 0;                    // NaN
Math.sqrt(-1);            // NaN
parseInt('hello');        // NaN
parseFloat('1.2.3');      // NaN (1.2)

// Операции с типами
'text' - 5;               // NaN
undefined + 5;            // NaN (не всегда)
{} * 2;                   // NaN

// Явное присвоение
Number.NaN;               // NaN

Лучшие практики

1. Используйте Number.isNaN() - это стандартный способ в современном JavaScript
2. Избегайте глобальной функции isNaN() - она имеет неправильное поведение
3. Всегда проверяйте результаты операций деления - особенно 0/0
4. Используйте parseFloat/parseInt с проверкой - они могут вернуть NaN
5. Для типобезопасности комбинируйте с typeof - если нужна уверенность в типе

Резюме

• Number.isNaN() - правильный и рекомендуемый способ
• isNaN() - имеет побочные эффекты, избегайте
• Object.is(value, NaN) - также работает
• NaN !== NaN - основное отличие от других значений
• Всегда используйте Number.isNaN() в production коде