Ben sadece Firefox'un JavaScript konsolunda deniyorum, ancak aşağıdaki ifadelerden hiçbiri doğru dönmüyor:

parseFloat('geoff') == NaN;

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

Bu kodu deneyin:

isNaN(parseFloat("geoff"))

Yalnızca sayı yerine herhangi bir değerin NaN olup olmadığını denetlemek için buraya bakın: Javascript'te NaN'yi nasıl test edersiniz?

Az önce etkili JavaScript kitabında bu teknikle karşılaştım :

NaN, kendisine eşit olmayan bir işlem olarak kabul edilen tek JavaScript değeri olduğundan, bir değerin kendisine eşit olup olmadığını kontrol ederek NaN olup olmadığını her zaman test edebilirsiniz:

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 yorum yapana kadar bunu fark etmedim, ama bu ECMA spesifikasyonunda: https://tc39.github.io/ecma262/#sec-isnan-number

Bu kodu kullanın:

isNaN('geoff');

isNaN()MDN'deki belgelere bakın .

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

Number türünde bir değer olup olmadığına bakılmaksızın NaN, global işlev isNaNişi yapacak

isNaN(any-Number);

JS'deki tüm türler için çalışan genel bir yaklaşım için aşağıdakilerden herhangi birini kullanabiliriz:

ECMAScript-5 Kullanıcıları için:

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

ECMAScript-6 kullanan kişiler için:

#2
Number.isNaN(x);

ECMAScript 5 & 6'nın her ikisinde de tutarlılık amacıyla, bu çoklu dolguyu Number.isNan için de kullanabiliriz

#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;
}

daha fazla bilgi için lütfen Bu Cevabı kontrol edin .

NaN böyle test edilemeyen özel bir değerdir. Sadece paylaşmak istediğim ilginç bir şey

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

Bu sadece NaN değerleri için geçerlidir ve güvenli bir test yöntemidir. Kesinlikle bir fonksiyona sarılmalıdır veya en azından yorumlanır, çünkü aynı değişkenin birbirine eşit olup olmadığını test etmek çok mantıklı değildir, hehe.

Genel isNaN(value)işlev çağrısını kullanmalısınız , çünkü:

• Çapraz tarayıcı desteklenir
• Dokümantasyon için bkz.

Örnekler:

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

Umarım bu sana yardımcı olmuştur.

İtibariyle ES6 , Object.is(..)mutlak eşitlik için iki değer test etmek için kullanılabilecek yeni bir araçtır:

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

'1.2geoff'Ayrıştırılan sorunu çözmek için Number()bunun yerine ayrıştırıcıyı kullanmanız yeterlidir.

Bundan ziyade:

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

Bunu yap:

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

EDIT: Ben sadece başka bir sorunu fark ettim ama ... yanlış değerleri (ve gerçek bir boole olarak doğru) Number()dönüş olarak geçti 0! Bu durumda ... parseFloat her seferinde çalışır. Öyleyse buna geri dönün:

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

Ve bu görünüşte her şeyi kapsıyor. Onu lodash'lardan% 90 daha yavaş karşılaştırdım, _.isNaNancak o zaman tüm NaN'leri kapsamıyor :

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

Sadece açık olmak gerekirse, benimki "Sayı Değil" olan bir şeyin insan edebî yorumunu ve lodash's bir şeyin "NaN" olup olmadığını kontrol etmek için bilgisayarın kelimenin tam anlamıyla yorumunu halleder.

@Chiborg'un cevabı doğru olsa da, not edilmesi gereken daha çok şey var:

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

Girdi doğrulamak için bu yöntemi kullanıyorsanız, sonuç oldukça liberal olacaktır.

Yani, evet kullanabilirsiniz parseFloat(string)(veya tam sayılar durumunda parseInt(string, radix)'ve daha sonra bunu ile sarın isNaN(), ancak ek sayısal olmayan karakterlerle iç içe numaralarla gotcha'nın farkında olun.

Basit Çözüm!

GERÇEKTEN süper basit! Buraya! Bu yöntemi kullanın!

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

Şu kadar basit kullanın:

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

hereBu işlevi kullanarak performans testine bakın vsselected answer

Ayrıca: Birkaç alternatif uygulama için 1. örneğe bakın.

Misal:

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>

Alternatif olarak adlandırılmış bir yöntem kullanmak istemiyorsanız ve daha global olarak kullanılabilir olmasını sağlamak istiyorsanız, uygulama için izlediğiniz birkaç alternatif yol vardır. Uyarı Bu çözümler yerel nesnelerin değiştirilmesini içerir ve en iyi çözümünüz olmayabilir. Her zaman dikkatli olun ve kullanabileceğiniz diğer Kitaplıkların yerel koda veya benzer değişikliklere bağlı olabileceğini unutmayın.

Alternatif Uygulama 1: Yerel isNaNyöntemi değiştirin .

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

Alternatif Uygulama 2: Sayı Nesnesine Ekle
^{* ECMA 5 ila 6 için bir poli dolgu olduğu için önerildi}

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

Boşsa alternatif çözüm _testi

Basit bir pencere yöntemi Ben nesne Boş olup olmadığını test yazdı . Öğe "tam" NaN ise vermediği için biraz farklı , ama boş eşyaları ararken de yararlı olabileceğinden bunu attığımı düşündüm.

/** 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);
})();

Misal:

;(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>

Boş Olduğunda Son Derece Derin Kontrol

Bu sonuncusu, bir nesnenin boş nesnelerle dolu olup olmadığını kontrol ederek biraz derinlere iner. Eminim iyileştirme ve olası çukurlar için yer var, ama şimdiye kadar, her şeyi yakalamak gibi görünüyor.

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>

Sadece başka bir alternatif paylaşmak istiyorum, burada diğerlerinden daha iyi değil, ama bence bakmaya değer:

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

Bunun arkasındaki mantık hariç her numara olduğunu 0ve NaNşekilde dökülmüştürtrue .

Hızlı bir test yaptım ve Number.isNaNyanlış için kendini kontrol etmek kadar iyi performans gösteriyor . Üçü de daha iyi performans gösteriyorisNan

Sonuçlar

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

Kırık isNaNişlevden kaçınmak istiyorsanız yararlı olabilir .

Ortamınız ECMAScript 2015'i destekliyorsaNumber.isNaN , değerin gerçekten olduğundan emin olmak için kullanmak isteyebilirsiniz.NaN .

Sorun isNaN, eğer sayısal olmayan verilerle kullanırsanız, çok az kafa karıştırıcı kural vardır (MDN'ye göre) uygulanır. Örneğin,

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

Bu nedenle, ECMA Script 2015 destekli ortamlarda,

Number.isNaN(parseFloat('geoff'))

JavaScript'teki NaN, türü aslında sayı olmasına rağmen "Not A Number" anlamına gelir.

typeof(NaN) // "number"

Bir değişkenin NaN değerine sahip olup olmadığını kontrol etmek için isNaN () işlevini kullanamayız, çünkü isNaN () aşağıdaki sorunu içerir, aşağıya bakın:

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

Burada gerçekten olan şey, myVar'ın bir sayıya dolaylı olarak zorlanmasıdır:

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

Aslında mantıklı, çünkü "A" aslında bir sayı değil. Ama gerçekten kontrol etmek istediğimiz şey, myVar'ın tam olarak NaN değeri olup olmadığıdır.

Yani isNaN () yardımcı olamaz. Öyleyse bunun yerine ne yapmalıyız?

NaN'ın kendisine eşit olmayan bir şekilde ele alınan tek JavaScript değeri ışığında,! == kullanarak eşitliğini kendisi kontrol edebiliriz.

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

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

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

Sonuç olarak , bir değişkenin = == doğru olduğu doğruysa, bu değişken tam olarak NaN değerindedir:

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

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

JavaScript'te alt çizgiisNaN işlevini kullanıyorum :

isNaN(undefined) 
-> true

En azından, bu yakalandığının farkında ol.

Belki de bu:

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

Görünüşe göre isNaN () kutunun dışında Node.js'de desteklenmiyor.
İle çalıştım

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

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

Eşitlik operatörü (== ve ===) bir değeri NaN'ye karşı test etmek için kullanılamaz.

Mozilla Belgelerine Bakın Global NaN özelliği, Not-A-Numbe'yi temsil eden bir değerdir

En iyi yol, NaN'yi kontrol etmek için buit-in fonksiyonu olan 'isNaN ()' kullanmaktır. Tüm tarayıcılar yolu destekler ..

Kural:

NaN != NaN

İsNaN () işlevinin sorunu, bazı durumlarda beklenmedik sonuç döndürebilmesidir:

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

Değerin gerçekten NaN olup olmadığını kontrol etmenin daha iyi bir yolu:

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

is_nan(parseFloat("geoff"))

IEEE 754'e göre, NaN içeren tüm ilişkiler! = Hariç yanlış olarak değerlendirilir. Dolayısıyla, örneğin, A veya B veya her ikisi de NaN ise (A> = B) = yanlış ve (A <= B) = yanlış.

Bu yanıtı başka ne zaman kontrol başka bir soruya StackOverflow yazdım NaN == nullama sonra yinelenen olarak işaretlendi, bu yüzden işimi boşa harcamak istemiyorum.

Hakkında Mozilla Geliştirici Ağı'na bakın NaN.

Kısa cevap

Sadece kullanmak distance || 0olmak istediğiniz zaman emin değeri uygun bir sayıdır veya isNaN()bunu kontrol etmek.

Uzun cevap

NaN (Sayı Değil), bazı matematik işlemleri başarısız olduğunda sık sık döndürülen javascript'teki tuhaf bir Global Nesnedir.

NaN == nullHangi sonuçların olup olmadığını kontrol etmek istediniz false. Hovewer bile NaN == NaNsonuç verir false.

Değişkenin NaNküresel bir işlev olup olmadığını öğrenmenin basit bir yolu isNaN().

Bir diğeri, x !== xsadece x NaN olduğunda doğrudur. (@ raphael-schweikert'e hatırlattığınız için teşekkürler)

Peki neden kısa cevap işe yaradı?

Hadi bulalım.

Aradığınızda NaN == falsesonuç false, ile aynıdır NaN == true.

Spesifikasyonlarda bir yerde JavaScript'in her zaman yanlış değerlere sahip bir kaydı vardır;

• NaN - Sayı Değil
• "" - boş dize
• false - bir mantıksal yanlış
• null - boş nesne
• undefined - tanımsız değişkenler
• 0 - +0 ve -0 dahil olmak üzere sayısal 0

Başka bir çözüm MDN'nin parseFloat sayfasında belirtilmiştir

Sıkı ayrıştırma yapmak için bir filtre işlevi sağlar

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

Ve sonra isNaNkontrol etmek için kullanabilirsinizNaN

Kontrol etmenin kesin yolu:

//takes care of boolen, undefined and empty

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

Bir cazibe gibi çalışan bu küçük işlevi yarattım. Karşı sezgisel görünen NaN'yi kontrol etmek yerine, bir numarayı kontrol edersiniz. Bu şekilde ilk yapan ben olmadığımdan eminim ama paylaşacağımı düşündüm.

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

    return retval;
}

Sadece eğlence için başka bir yol buldum.

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

marksyzm'ın cevabı iyi çalışıyor, ancak InfinityInfinity teknik olarak bir sayı olmadığı için yanlış dönmüyor.

i isNumberbir sayı olup olmadığını kontrol edecek bir işlev ile geldi .

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

GÜNCELLEME: bu kod bazı parametreler için başarısız olduğunu fark ettim, bu yüzden daha iyi yaptım.

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

Bu zarif değil. ama isNAN () denedikten sonra başka bir alternatif olan bu çözüme ulaştım. Bu örnekte ayrıca '.' çünkü şamandıra için maskeliyorum. Hiçbir numara kullanılmadığından emin olmak için bunu tersine çevirebilirsiniz.

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

Bu tek karakterlik bir değerlendirmedir, ancak herhangi bir sayı olup olmadığını kontrol etmek için bir dizede de döngü yapabilirsiniz.

NaN'yi isNaN javascript işlevini kullanarak kontrol edebilirsiniz. Sadece sayıyı veya değeri isNaN işlevine geçirmek

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

Sonucu String'e dönüştürün ve 'NaN' ile karşılaştırın.

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

Mı (NaN> = 0) ? ...... " Ben do not Know ".

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

Koşullar yalnızca DOĞRU ise uygulanır .

FALSE üzerinde değil .

" Bilmiyorum " da değil .