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

parseFloat('geoff') == NaN;

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

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

isNaN(parseFloat("geoff"))

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

Я только что столкнулся с этой техникой в ​​книге « Эффективный 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

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

isNaN('geoff');

Смотрите isNaN()документы по MDN .

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

Поскольку значение типа 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;
}

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

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

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

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

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

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

Примеры:

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

Я надеюсь, что это поможет вам.

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

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

Чтобы исправить проблему с '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

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

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

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

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

Просто чтобы прояснить, моя заботится о человеческой буквальной интерпретации чего-то, что является «Не числом», а Лодаш заботится о компьютерной буквальной интерпретации проверки, является ли что-то «NaN».

Хотя ответ @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(), но будьте внимательны с полученными числами, переплетенными с дополнительными нечисловыми символами.

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

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

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

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

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

Смотрите тест производительностиhere с помощью этой функции против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>

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

Альтернативная реализация 1: Заменить собственный isNaNметод.

//  Extremely simple. Just simply write the method.
window.isNaN = function(a) { return a !==a; }

Альтернативная реализация 2: добавление к объекту нумерации ^* Предложено, так
^{как оно также является полизаполнением для ECMA 5-6}

Number['isNaN'] || (Number.isNaN = function(a) { return a !== a });
//  Use as simple as
Number.isNaN(NaN)

_{Проверка} альтернативного раствора, _{если она пуста}

Простой метод окна я написал этот тест, если объект пуст . Это немного отличается тем, что не дает, если элемент «точно» NaN , но я решил, что это будет важно, так как это может быть полезно при поиске пустых элементов.

/** isEmpty(varried)
 *  Simple method for testing if item is "empty"
 **/
;(function() {
   function isEmpty(a) { return (!a || 0 >= a) || ("object" == typeof a && /\{\}|\[(null(,)*)*\]/.test(JSON.stringify(a))); };
   window.hasOwnProperty("empty")||(window.empty=isEmpty);
})();

Пример:

;(function() {
   function isEmpty(a) { return !a || void 0 === a || a !== a || 0 >= a || "object" == typeof a && /\{\}|\[(null(,)*)*\]/.test(JSON.stringify(a)); };
   window.hasOwnProperty("empty")||(window.empty=isEmpty);
})();

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': new Array(),
    'an empty Array w/ 9 len': new Array(9),
    '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 = empty(example[x]),
		strAnswer = answer.toString();
	$("#t1").append(
		$("<tr />", { "class": strAnswer }).append(
			$("<th />", { html: x }),
			$("<td />", { html: strAnswer.toUpperCase() })
		)
	)
};


function isReallyNaN(a) { return a !== a; };
for(x in example){var answer=isReallyNaN(example[x]),strAnswer=answer.toString();$("#t2").append($("<tr />",{"class":strAnswer}).append($("<th />",{html:x}),$("<td />",{html:strAnswer.toUpperCase()})))};

table { border-collapse: collapse; float: left; }
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 id="t1"><thead><tr><th colspan="2">isEmpty()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>
<table id="t2"><thead><tr><th colspan="2">isReallyNaN()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>

Очень глубокая проверка, если пуст

Этот последний идет немного глубже, даже проверяя, заполнен ли объект пустыми объектами. Я уверен, что в нем есть место для улучшений и возможных ям, но пока что, похоже, ловит почти все.

function isEmpty(a) {
	if (!a || 0 >= a) return !0;
	if ("object" == typeof a) {
		var b = JSON.stringify(a).replace(/"[^"]*":(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '').replace(/"[^"]*":\{\},?/g, '');
		if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		else if (a instanceof Array)  {
			b = b.replace(/(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '');
			if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		}
	}
	return false;
}
window.hasOwnProperty("empty")||(window.empty=isEmpty);

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': new Array(),
    'an empty Array w/ 9 len': new Array(9),
    'a semi-passed parse': parseInt('5a5'),
    'a non-empty Array': [ 'a', 'b', 'c' ],
    'Math to NaN': Math.log(-1),
    'an undefined object': undefined,
    'Object Full of Empty Items': { 1: '', 2: [], 3: {}, 4: false, 5:new Array(3), 6: NaN, 7: null, 8: void 0, 9: 0, 10: '0', 11: { 6: NaN, 7: null, 8: void 0 } },
    'Array Full of Empty Items': ["",[],{},false,[null,null,null],null,null,null,0,"0",{"6":null,"7":null}]
  }

for (x in example) {
	var answer = empty(example[x]),
		strAnswer = answer.toString();
	$("#t1").append(
		$("<tr />", { "class": strAnswer }).append(
			$("<th />", { html: x }),
			$("<td />", { html: strAnswer.toUpperCase() })
		)
	)
};


function isReallyNaN(a) { return a !== a; };
for(x in example){var answer=isReallyNaN(example[x]),strAnswer=answer.toString();$("#t2").append($("<tr />",{"class":strAnswer}).append($("<th />",{html:x}),$("<td />",{html:strAnswer.toUpperCase()})))};

table { border-collapse: collapse; float: left; }
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 id="t1"><thead><tr><th colspan="2">isEmpty()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>
<table id="t2"><thead><tr><th colspan="2">isReallyNaN()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>

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

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

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

Я сделал быстрый тест, и он работает так же хорошо, как Number.isNaN и проверяет себя на ложность. Все три работают лучше, чем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функции.

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

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

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

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

Number.isNaN(parseFloat('geoff'))

NaN в JavaScript означает «не число», хотя на самом деле его тип - число.

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

Я использую функцию подчеркивания,isNaN потому что в JavaScript:

isNaN(undefined) 
-> true

По крайней мере, помните об этом.

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

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

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

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

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

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

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

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

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

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"))

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

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

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

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

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

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

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

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

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

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

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

Давайте выясним.

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

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

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

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

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

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

Точный способ проверить это:

//takes care of boolen, undefined and empty

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

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

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

    return retval;
}

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

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

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

я придумал 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"));

ОБНОВЛЕНИЕ: я заметил, что этот код не работает для некоторых параметров, поэтому я сделал его лучше.

function isNumber(i) {//function for checking if parameter is number
if(!arguments.length) {
throw new SyntaxError("not enough arguments.");
	} else if(arguments.length > 1) {
throw new SyntaxError("too many arguments.");
	} else if([Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY].indexOf(i) !== -1) {
throw new RangeError("number cannot be \xB1infinity.");
	} else if(typeof i === "object" && !(i instanceof RegExp) && !(i instanceof Number) && !(i === null)) {
throw new TypeError("parameter cannot be object/array.");
	} else if(i instanceof RegExp) {
throw new TypeError("parameter cannot be RegExp.");
	} else if(i == null || i === undefined) {
throw new ReferenceError("parameter is null or undefined.");
	} else {
return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && (i === i);
	}
}
console.log(isNumber(Infinity));
console.log(isNumber(this));
console.log(isNumber(/./ig));
console.log(isNumber(null));

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

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

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

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

Вы можете проверить NaN, используя функцию javascript isNaN. Просто передав число или значение в функцию isNaN

isNaN(123) //false
isNaN(-1.23) //false
isNaN(5-2) //false
isNaN(0) //false
isNaN('123') //false
isNaN('Hello') //true
isNaN('2005/12/12') //true
isNaN('') //false
isNaN(true) //false
isNaN(undefined) //true
isNaN('NaN') //true
isNaN(NaN) //true
isNaN(0 / 0) //true

Просто конвертируйте результат в строку и сравните с NaN.

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

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

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

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

Не на ЛОЖЬ .

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