Я спробував це лише в консолі JavaScript Firefox, але жодне з наведених нижче тверджень не відповідає дійсності:

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 обох, ми також можемо використовувати цю поліфункцію для 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

EDIT: Я щойно помітив ще одне питання з цього, хоча ... помилкові значення (і справжні як справжній бул) перейшли у 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

Також: Дивіться нижче перший приклад для пари альтернативних реалізацій.

Приклад:

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але тоді він був позначений як дублікат, тому я не хочу витрачати роботу.

Подивіться про Мережу розробників MozillaNaN .

Коротка відповідь

Просто використовуйте, distance || 0коли ви хочете, щоб переконатися, що вам належне число, або isNaN()перевірити його.

Довга відповідь

NaN (Not-a-Number) - це дивний глобальний об'єкт в JavaScript, який часто повертається, коли деякі математичні операції не вдалися.

Ви хотіли перевірити, NaN == nullякі результати false. Ховевер навіть NaN == NaNрезультати зfalse .

Простий спосіб дізнатися, чи є змінною NaNглобальна функціяisNaN() .

Інша є x !== x це справедливо лише тоді, коли x - NaN. (дякую за нагадування @ raphael-schweikert)

Але чому коротка відповідь спрацювала?

Давай дізнаємось.

Коли ви телефонуєте, NaN == falseрезультат те саме false, що і з NaN == true.

Десь у специфікаціях JavaScript має запис із завжди помилковими значеннями, який включає:

• NaN - Не-номер
• "" - порожній рядок
• false - булева помилка
• null - нульовий об’єкт
• undefined - невизначені змінні
• 0 - числовий 0, включаючи +0 і -0

Ще одне рішення згадується в Росії сторінці розбору 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);  
}

Відповідь markyzm працює добре, але вона не повертає хибну, Infinityоскільки 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 за допомогою функції jaNaN JavaScript. Просто передавання числа або значення функції 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

Просто конвертуйте результат у String та порівняйте з "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;
}

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

Не FALSE .

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