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

Я только пробовал его в консоли JavaScript Firefox, но ни одно из следующих утверждений не возвращает true:

parseFloat('geoff') == NaN;

parseFloat('geoff') == Number.NaN;

ОТВЕТЫ

Ответ 1

Попробуйте этот код:

isNaN(parseFloat("geoff"))

Для проверки, есть ли какое-либо значение NaN, а не просто числа, см. здесь: Как вы проверяете NaN в Javascript?

Ответ 2

Я только что столкнулся с этой техникой в книге Эффективный JavaScript, которая довольно проста:

Поскольку NaN является единственным значением JavaScript, которое рассматривается как неравное для себя, вы всегда можете проверить, является ли значение NaN, проверив его на равенство с самим собой:

var a = NaN;
a !== a; // true 

var b = "foo";
b !== b; // false 

var c = undefined; 
c !== c; // false

var d = {};
d !== d; // false

var e = { valueOf: "foo" }; 
e !== e; // false

Не осознавал этого, пока @allsyed не прокомментировал, но это в спецификации ECMA: https://tc39.github.io/ecma262/#sec-isnan-number

Ответ 3

Используйте этот код:

isNaN('geoff');

Смотрите isNaN() docs на MDN.

alert ( isNaN('abcd'));  // alerts true
alert ( isNaN('2.0'));  // alerts false
alert ( isNaN(2.0));  // alerts false

Ответ 4

Поскольку значение типа Number должно быть проверено, является ли оно NaN или нет, глобальная функция isNaN выполнит эту работу.

isNaN(any-Number);

Для общего подхода, который работает для всех типов в JS, мы можем использовать любое из следующего:

Для пользователей ECMAScript-5:

#1
if(x !== x) {
    console.info('x is NaN.');
}
else {
    console.info('x is NOT a NaN.');
}

Для людей, использующих ECMAScript-6:

#2
Number.isNaN(x);

И в целях обеспечения согласованности в ECMAScript 5 и 6, мы также можем использовать этот polyfill для Number.isNan

#3
//Polyfill from MDN
Number.isNaN = Number.isNaN || function(value) {
    return typeof value === "number" && isNaN(value);
}
// Or
Number.isNaN = Number.isNaN || function(value) {     
    return value !== value;
}

пожалуйста, проверьте этот ответ для более подробной информации.

Ответ 5

NaN - особое значение, которое невозможно проверить таким образом. Интересная вещь, которую я просто хотел поделиться, это

var nanValue = NaN;
if(nanValue !== nanValue) // Returns true!
    alert('nanValue is NaN');

Это возвращает true только для значений NaN и является безопасным способом тестирования. Должно быть обязательно завернуто в функцию или, по крайней мере, прокомментировано, потому что не имеет смысла явно проверять, не совпадает ли одна и та же переменная, хе-хе.

Ответ 6

Вы должны использовать глобальный вызов функции isNaN(value), потому что:

  • Поддерживается кросс-браузер
  • Смотрите isNaN для документации

Примеры:

 isNaN('geoff'); // true
 isNaN('3'); // false

Надеюсь, это поможет вам.

Ответ 7

Как и в ES6, Object.is(..) - это новая утилита, которая может использоваться для проверки двух значений для абсолютного равенства:

var a = 3 / 'bar';
Object.is(a, NaN); // true

Ответ 8

Чтобы решить проблему, когда '1.2geoff' анализируется, просто используйте вместо этого анализатор Number().

Итак, а не это:

parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true

Сделай это:

Number('1.2geoff'); // => NaN
isNaN(Number('1.2geoff')); // => true
isNaN(Number('.2geoff')); // => true
isNaN(Number('geoff')); // => true

РЕДАКТИРОВАТЬ: я только что заметил еще одну проблему из этого, хотя... ложные значения (и истина как реальное логическое значение), переданные в Number() возвращаются как 0 ! В этом случае... parseFloat работает каждый раз вместо этого. Итак, вернемся к этому:

function definitelyNaN (val) {
    return isNaN(val && val !== true ? Number(val) : parseFloat(val));
}

И это охватывает, казалось бы, все. Я тестировал его на 90% медленнее, чем lodash _.isNaN но тогда он не охватывает все NaN:

http://jsperf.com/own-isnan-vs-underscore-lodash-isnan

Просто чтобы прояснить, моя заботится о человеческой буквальной интерпретации чего-то, что является "не числом", а lodash заботится о компьютерной буквальной интерпретации проверки, является ли что-то "NaN".

Ответ 9

В то время как ответ @chiborg правильный, есть еще что-то, что следует отметить:

parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true

Точка, если вы используете этот метод для проверки ввода, результат будет довольно либеральным.

Итак, да, вы можете использовать parseFloat(string) (или в случае полных чисел parseInt(string, radix) ', а затем обернуть это с помощью isNaN(), но помните о полученной информации с номерами, переплетенными с дополнительными нечисловыми символами.

Ответ 10

Простое решение!

ДЕЙСТВИТЕЛЬНО супер просто! Вот! Имейте этот метод!

function isReallyNaN(a) { return a !== a; };

Использовать так же просто, как:

if (!isReallyNaN(value)) { return doingStuff; }

См. тест производительности here, используя этот func vs selected answer

Также: см. ниже 1-й пример для нескольких альтернативных реализаций.

Пример:

function isReallyNaN(a) { return a !== a; };

var example = {
    'NaN': NaN,
    'an empty Objet': {},
    'a parse to NaN': parseFloat('$5.32'),
    'a non-empty Objet': { a: 1, b: 2 },
    'an empty Array': [],
    'a semi-passed parse': parseInt('5a5'),
    'a non-empty Array': [ 'a', 'b', 'c' ],
    'Math to NaN': Math.log(-1),
    'an undefined object': undefined
  }

for (x in example) {
    var answer = isReallyNaN(example[x]),
        strAnswer = answer.toString();
    $("table").append($("<tr />", { "class": strAnswer }).append($("<th />", {
        html: x
    }), $("<td />", {
        html: strAnswer
    })))
};
table { border-collapse: collapse; }
th, td { border: 1px solid; padding: 2px 5px; }
.true { color: red; }
.false { color: green; }
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table></table>

Ответ 11

Если ваша среда поддерживает ECMAScript 2015, то вы можете использовать Number.isNaN чтобы убедиться, что значение действительно NaN.

Проблема с isNaN заключается в том, что, если вы используете это с нечисловыми данными, применяется несколько непонятных правил (согласно MDN). Например,

isNaN(NaN);       // true
isNaN(undefined); // true
isNaN({});        // true

Итак, в средах, поддерживаемых ECMA Script 2015, вы можете использовать

Number.isNaN(parseFloat('geoff'))

Ответ 12

Я использую функцию underscore isNaN, потому что в JavaScript:

isNaN(undefined) 
-> true

По крайней мере, помните о том, что было получено.

Ответ 13

NaN в JavaScript означает "Not A Number", хотя его тип фактически является номером.

typeof(NaN) // "number"

Чтобы проверить, имеет ли переменная значение NaN, мы не можем просто использовать функцию isNaN(), потому что isNaN() имеет следующую проблему, см. ниже:

var myVar = "A";
isNaN(myVar) // true, although "A" is not really of value NaN

Что действительно происходит, так это то, что myVar неявно принуждается к числу:

var myVar = "A";
isNaN(Number(myVar)) // true. Number(myVar) is NaN here in fact

Это действительно имеет смысл, потому что "А" на самом деле не является числом. Но мы действительно хотим проверить, действительно ли myVar имеет значение NaN.

Так isNaN() не может помочь. Тогда что мы должны делать вместо этого?

В свете того, что NaN является единственным значением JavaScript, которое обрабатывается неравномерно, поэтому мы можем проверить его равенство для себя, используя! ==

var myVar; // undefined
myVar !== myVar // false

var myVar = "A";
myVar !== myVar // false

var myVar = NaN
myVar !== myVar // true

Итак, чтобы заключить, если это правда, что сама переменная! ==, то эта переменная имеет точно значение NaN:

function isOfValueNaN(v) {
    return v !== v;
}

var myVar = "A";
isNaN(myVar); // true
isOfValueNaN(myVar); // false

Ответ 14

Кажется, что isNaN() не поддерживается в Node.js из коробки.
Я работал с

var value = 1;
if (parseFloat(stringValue)+"" !== "NaN") value = parseFloat(stringValue);

Ответ 15

Я просто хочу поделиться другой альтернативой, это не обязательно лучше, чем другие, но я думаю, стоит посмотреть:

function customIsNaN(x) { return (typeof x == 'number' && x != 0 && !x); }

Логика заключается в том, что каждое число, кроме 0 и NaN, добавляется к true.

Я сделал быстрый тест, и он работает так же хорошо, как Number.isNaN и как проверка на себя для false. Все три выполняют лучше, чем isNan

Результаты

customIsNaN(NaN);            // true
customIsNaN(0/0);            // true
customIsNaN(+new Date('?')); // true

customIsNaN(0);          // false
customIsNaN(false);      // false
customIsNaN(null);       // false
customIsNaN(undefined);  // false
customIsNaN({});         // false
customIsNaN('');         // false

Может стать полезным, если вы хотите избежать сломанной функции isNan.

Ответ 16

function isNotANumber(n) {
  if (typeof n !== 'number') {
    return true;
  } 
  return n !== n;
}

Ответ 17

NaN === NaN;        // false
Number.NaN === NaN; // false
isNaN(NaN);         // true
isNaN(Number.NaN);  // true

Оператор равенства (== и ===) не может использоваться для проверки значения против NaN.

Посмотрите Документация Mozilla Глобальное свойство NaN представляет собой значение, представляющее Not-A-Numbe

Лучший способ - использовать 'isNaN()', который является функцией buit-in для проверки NaN. Все браузеры поддерживают способ.

Ответ 18

Точный способ проверки:

//takes care of boolen, undefined and empty

isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number'

Ответ 19

Возможно также это:

function isNaNCustom(value){
    return value.toString() === 'NaN' && 
           typeof value !== 'string' && 
           typeof value === 'number'
}

Ответ 20

Согласно IEEE 754, все отношения, связанные с NaN, оцениваются как false, кроме! =. Таким образом, например, (A >= B) = false и (A <= B) = false, если A или B или оба являются NaN.

Ответ 21

Я написал этот ответ на другой вопрос fooobar.com/questions/24725/..., где другой проверяет, когда NaN == null, но затем он был помечен как дубликат, поэтому я не хочу тратить моя работа.

Посмотрите Сеть разработчиков Mozilla около NaN.

Короткий ответ

Просто используйте distance || 0, когда вы хотите убедиться, что вы используете правильное число или isNaN(), чтобы проверить его.

Длинный ответ

NaN (Not-a-Number) - глобальный объект Weirdo в javascript, который часто возвращается, когда некоторая математическая операция не удалась.

Вы хотите проверить, если NaN == null результат false. Hovewer даже NaN == NaN приводит к false.

Простой способ узнать, является ли переменная NaN глобальной функцией isNaN().

Другим является x !== x, что справедливо только тогда, когда x является NaN. (спасибо, чтобы напомнить @raphael-schweikert)

Но почему сработал короткий ответ?

Выясните.

Когда вы вызываете NaN == false, результат равен false, то же самое с NaN == true.

Где-то в спецификациях JavaScript имеет запись с всегда ложными значениями, которая включает в себя:

  • NaN - Не-номер
  • "" - пустая строка
  • false - логическое значение false
  • null - нулевой объект
  • undefined - undefined переменные
  • 0 - числовое число 0, включая +0 и -0

Ответ 22

Другое решение упоминается в странице MDN parseFloat

Он предоставляет функцию фильтра для строгой разборки

var filterFloat = function (value) {
    if(/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/
      .test(value))
      return Number(value);
  return NaN;
}


console.log(filterFloat('421'));               // 421
console.log(filterFloat('-421'));              // -421
console.log(filterFloat('+421'));              // 421
console.log(filterFloat('Infinity'));          // Infinity
console.log(filterFloat('1.61803398875'));     // 1.61803398875
console.log(filterFloat('421e+0'));            // NaN
console.log(filterFloat('421hop'));            // NaN
console.log(filterFloat('hop1.61803398875'));  // NaN

И затем вы можете использовать isNaN, чтобы проверить, есть ли это NaN

Ответ 23

Я создал эту небольшую функцию, которая работает как шарм. Вместо проверки на NaN, который, кажется, встречный интуитивный, вы проверяете число. Я уверен, что я не первый, кто сделал это таким образом, но я думал, что хочу поделиться.

function isNum(val){
    var absVal = Math.abs(val);
    var retval = false;
    if((absVal-absVal) == 0){
        retval = true
    }

    return retval;
}

Ответ 24

Нашел другой способ, просто для удовольствия.

function IsActuallyNaN(obj) {
  return [obj].includes(NaN);  
}

Ответ 25

Ответ marksyzm работает хорошо, но он не возвращает false для Infinity, поскольку Infinity технически не является числом.

i появилась функция isNumber, которая будет проверять, является ли это числом.

function isNumber(i) {
    return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY].indexOf(i) === -1;
}

console.log(isNumber(Infinity));
console.log(isNumber("asdf"));
console.log(isNumber(1.4));
console.log(isNumber(NaN));
console.log(isNumber(Number.MAX_VALUE));
console.log(isNumber("1.68"));

Ответ 26

alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);

Это не изящно. но после попытки isNAN() я пришел к этому решению, что является другой альтернативой. В этом примере я также разрешил '.' потому что я маскирую для float. Вы также можете отменить это, чтобы убедиться, что номера не используются.

("1234567890".indexOf(String.fromCharCode(mycharacter))==-1)

Это оценка одного символа, но вы также можете прокручивать строку для проверки любых чисел.

Ответ 27

Является (NaN >= 0)?...... " Я не знаю".

function IsNotNumber( i ){
    if( i >= 0 ){ return false; }
    if( i <= 0 ){ return false; }
    return true;
}

Условия выполняются только в том случае, если ИСТИНА.

Не на ЛОЖЬ.

Не на " Я не знаю".

Ответ 28

Правило таково:

NaN != NaN

Проблема функции isNaN() в том, что она может возвращать неожиданный результат в некоторых случаях:

isNaN('Hello')      //true
isNaN('2005/12/12') //true
isNaN(undefined)    //true
isNaN('NaN')        //true
isNaN(NaN)          //true
isNaN(0 / 0)        //true

Лучший способ проверить, действительно ли значение NaN:

function is_nan(value) {
    return value != value
}

is_nan(parseFloat("geoff"))

Ответ 29

Просто преобразуйте результат в String и сравните с "NaN".

var val = Number("test");
if(String(val) === 'NaN') {
   console.log("true");
}

Ответ 30

if(isNaN("I am NotaNumber (NaN)") == true) {
    console.log("Not a Number")
}

if(isNaN(1) == false) {
    console.log("I am a number")
}