आप कैसे चेक करते हैं कि कोई नंबर जावास्क्रिप्ट में NaN है?

Question

मैं इसे केवल फ़ायरफ़ॉक्स के जावास्क्रिप्ट कंसोल में आज़मा रहा हूँ, लेकिन दोनों में से कोई भी कथन सही नहीं है:

parseFloat('geoff') == NaN;

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

Comments

पढ़ने के लायक अगर आपका वास्तविक लक्ष्य संख्याओं की जांच करना है: stackoverflow.com/questions/18082/…

— पॉल

designpepper.com/blog/drips/…

— फ़ोरएवर

@ गोथो: यकीन है, लेकिन मैंने पूछा कि कैसे जांच करें कि कोई संख्या NaN है, किसी भी मूल्य के विपरीत।

— पॉल डी। वेट

@ PaulD.Waite हां, लेकिन बहुत से लोग यहां आते हैं जब Googling कुछ ऐसा होता है जैसे "कैसे जांचा जाए कि कोई जावास्क्रिप्ट में नैनो है"।

— मिशैल पेरोलाकोव्स्की

पॉलड.वाइट मैं आपसे सहमत हूं, लेकिन मुझे वैसी ही चिंता है जैसी @ गोथो को है। बहुत से लोग इस सवाल पर इस इरादे से उतरते हैं कि "जेएस में कोई मान नहीं है तो कैसे जांचें"। आप उसी उत्तर पर mjohnsonengr की टिप्पणी देख सकते हैं । BTW, मैंने भी मध्यस्थों के ध्यान के लिए इस प्रश्न को चिह्नित किया है।

— dopeddude

Answer 1

इस कोड को आज़माएं:

isNaN(parseFloat("geoff"))

यह जाँचने के लिए कि क्या कोई मान NaN है, केवल संख्याओं के बजाय, यहाँ देखें: आप जावास्क्रिप्ट में NaN के लिए परीक्षण कैसे करते हैं?

Comments

क्या पासेफ्लोत की जरूरत है?

— राहुल

यदि आप चाहते हैं कि एक खाली स्ट्रिंग की व्याख्या की जाए NaN, तो हाँ। (मैं आपको हमेशा नहीं कह रहा हूँ।)

— पॉल डी। वेट

अगर मैं तुम होते तो मैं इसे एक चर में सौंप देता और, चर चर का उपयोग करता! == चर। जैसा कि इसे चश्मा में रखा गया है tc39.github.io/ecma262/#sec-isnan-number

— 5:36 पर

isNaN(parseFloat("geoff")) // true isNaN(parseFloat("10geo")) // false यह कैसे उपयोगी है?

— प्रशान्त

यह w3schools.com/jsref/jsref_isnan.asp

— श्रीजन चौधरी

Answer 2

मैं अभी-अभी इस तकनीक को प्रभावी जावास्क्रिप्ट पुस्तक में आया है जो बहुत सरल है:

चूंकि NaN केवल जावास्क्रिप्ट मान है जो अपने आप में असमान के रूप में व्यवहार किया जाता है, आप हमेशा यह परीक्षण कर सकते हैं कि क्या मान खुद के लिए समानता की जाँच करके 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

जब तक @allyed ने टिप्पणी नहीं की, तब तक इसका एहसास नहीं हुआ, लेकिन यह ECMA कल्पना में है: https://tc39.github.io/ecma262/#sec-isnan-number

Comments

प्रभावी लेकिन प्रतिवादात्मक। मैं इस तरह का कोड नहीं रखना चाहूंगा।

— osa

यह वह कोड नहीं है जो प्रतिवादात्मक है, यह NaN है।

— जाजज़ी

@DanM यह बग नहीं है, यह NaN का मानक IEE754 व्यवहार है। यह सीपीयू में कैसे लागू किया गया है, और यह दुनिया में हर प्रोग्रामिंग भाषा में अपेक्षित व्यवहार है जो फ्लोट्स का उपयोग करता है।

— टरमिल जूल

@ टरमिल ड्यूल ने नोट किया! यह वास्तव में दिलचस्प है; मैंने हमेशा सोचा था कि NaN असमानता अजीब एक जावास्क्रिप्ट चीज़ थी।

— दान एम

एनएन === नान; // असत्य। यह जावास्क्रिप्ट में एक ज्ञात बग है। isNan एक नई विधि है।

— atilkan

Answer 3

इस कोड का उपयोग करें:

isNaN('geoff');

isNaN()MDN पर डॉक्स देखें ।

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

Comments

हो सकता है कि यह सिर्फ मुझे है, लेकिन NaN के विचार जब भ्रमित हो जाता है var value = 0/0;और var value2= String("123 131");NaN मान बना सकते हैं और कुछ इस तरह var value3 = "abcd";यह भी एक NaN मूल्य है।

— निक पिनेडा

@NickPineda क्यों?

— सिंजई

Answer 4

जहाँ तक प्रकार संख्या के मान का परीक्षण किया जाना है कि यह एक कार्य है NaNया नहीं, वैश्विक कार्य isNaNकरेगा

isNaN(any-Number);

---

जेएससी के सभी प्रकारों के लिए काम करने वाले एक सामान्य दृष्टिकोण के लिए, हम निम्नलिखित में से किसी का उपयोग कर सकते हैं:

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

अधिक जानकारी के लिए कृपया इस उत्तर को देखें।

Comments

न केवल "नॉन ()" का उपयोग करने के लिए धन्यवाद, बल्कि पूरी तरह से विस्तृत जवाब प्रदान करना। यह वही है जो मैं तब खोज रहा था जब मुझे यह प्रश्न Google पर मिला था।

— mjohnsonengr

".... उपरोक्त मामलों के लिए गलत परिणाम दे रहा था" मैं गलत नहीं कहूंगा, बस अलग है, क्योंकि वैश्विक isNaNतर्क को एक संख्या मान में परिवर्तित करता है।

— फेलिक्स क्लिंग

@FelixKling अद्यतन किए गए उत्तर की जांच करें। धन्यवाद।

— dopeddude

isNaN ("लोरेम इप्सम"); // सच ES5 के साथ मेरे मन उड़ रहा था

— निक Pineda

@NickPineda भावना बहुत पारस्परिक है, लेकिन अंत में MDN इसे इस तरह समझा सकता है "जब isNaN फ़ंक्शन का तर्क प्रकार संख्या का नहीं है, तो मान को पहले एक संख्या के लिए ज़ब्त किया जाता है। परिणामी मान को यह निर्धारित करने के लिए परीक्षण किया जाता है कि क्या यह है। NaN। "

— dopeddude

Answer 5

NaN एक विशेष मूल्य है जिसे उस तरह से परीक्षण नहीं किया जा सकता है। एक दिलचस्प बात जो मैं सिर्फ साझा करना चाहता था वह यह है

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

यह केवल NaN मूल्यों के लिए सही है और परीक्षण का एक सुरक्षित तरीका है। निश्चित रूप से एक फ़ंक्शन में लपेटा जाना चाहिए या कम से कम टिप्पणी की जानी चाहिए, क्योंकि यह स्पष्ट रूप से परीक्षण करने के लिए बहुत मायने नहीं रखता है कि क्या एक ही चर एक दूसरे के बराबर नहीं है, हेह।

Comments

यह बिल्कुल विश्वसनीय तरीका नहीं है। ऐनक के अनुसार। चर! == चर NaN के लिए जाँच करने के लिए सबसे विश्वसनीय तरीका है

— allsyed

इस पर मेरा जवाब ऊपर देखें ^

— Jazzy

Answer 6

आपको वैश्विक isNaN(value)फ़ंक्शन कॉल का उपयोग करना चाहिए , क्योंकि:

• यह क्रॉस-ब्राउज़र समर्थित है
• प्रलेखन के लिए देखें NNN

उदाहरण:

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

उम्मीद है इससे आपको मदद मिलेगी।

Comments

हाँ, isNaN('') //falseलेकिन parseInt('') //NaN। उसी के लिए कहा जा सकता है null।

— साइलेंट पेंगुइन

Answer 7

ES6 के रूप में , Object.is(..)एक नई उपयोगिता है जिसका उपयोग पूर्ण समानता के लिए दो मूल्यों का परीक्षण करने के लिए किया जा सकता है:

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

Comments

MDN में NaN doc

— बजे

Answer 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% धीमी गति से बेंचमार्क किया, _.isNaNलेकिन फिर वह सभी NaN को कवर नहीं करता है:

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

बस स्पष्ट होने के लिए, मेरा किसी चीज़ की मानवीय शाब्दिक व्याख्या का ध्यान रखता है जो "नॉट नॉट" है और लॉश का कंप्यूटर की शाब्दिक व्याख्या की देखभाल करता है अगर कुछ "NaN" है।

Answer 9

जबकि @chiborg का उत्तर IS सही है, इसमें और भी बहुत कुछ है जिसे नोट किया जाना चाहिए:

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

यदि आप इनपुट के सत्यापन के लिए इस पद्धति का उपयोग कर रहे हैं, तो इसका परिणाम उदार होगा।

तो, हां आप parseFloat(string)(या पूर्ण संख्या के मामले में) का उपयोग कर सकते हैं parseInt(string, radix)और फिर बाद में उस के साथ लपेट सकते हैं isNaN(), लेकिन अतिरिक्त गैर-संख्यात्मक वर्णों के साथ intertwined संख्याओं के साथ गोचा के बारे में पता होना चाहिए।

Comments

दिलचस्प। किसी भी तरह से यह मुकाबला करने और यह पता लगाने के लिए कि "1.2geoff" वास्तव में एक वैध संख्या स्ट्रिंग नहीं है?

— गाबे हल्समर

ध्यान दें कि यह केवल तब होता है जब स्ट्रिंग एक संख्या से शुरू होती है । parseFloat('test1.2')वापस आ जाएगा NaN।

— एडुआर्ड लुका

Answer 10

सरल समाधान!

वास्तव में सुपर सरल! यहाँ! इस विधि है!

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>

Comments

@ PaulD.Waite शायद यह इस app है, लेकिन मैं एक स्वीकृत जवाब नहीं दिख रहा है। वास्तव में, मैं केवल 5 उत्तरों के बारे में देखता हूं, लेकिन मुझे लगता है कि यह कहता है कि 15 हैं

— SpYk3HH

आप किस ऐप का इस्तेमाल कर रहे हैं?

— पॉल डी। वेट

@ PaulD.Waite Android के लिए एसई एक। आकाशगंगा s3 पर

— SpYk3HH

अहा। मेरे पास खुद को देखने के लिए ऐप नहीं है, लेकिन यहां स्वीकृत उत्तर के लिए एक लिंक है: stackoverflow.com/a/2652335/20578

— पॉल डी। वेट

@ PaulD.Waite आह, मैं देख रहा हूं। मुझे लगता है, केवल और केवल स्वयं के प्रश्न के उत्तर में, वह उत्तर पर्याप्त हो सकता है। मैंने "जेएस तरीके से यह जांचने के लिए कि क्या वास्तव में 'NaN' है, के संबंध में एक और प्रश्न पर अपना जवाब पोस्ट किया, क्योंकि isNaNयह विश्वसनीय नहीं है। मुझे वहां टिप्पणी दी गई और बताया गया कि यह प्रश्न मेरे उत्तर के लिए बेहतर होगा, इस प्रकार इसे यहाँ स्थानांतरित किया जाएगा। बस इस मुद्दे के संबंध में कुछ उपयोगी / उपयोगी को बाहर रखना, जो हाथ में मुद्दे की Google खोज पर पॉप अप हो जाएगा is it NaN?। साइड नोट पर, मेरा उत्तर चयनित उत्तर की तुलना में अधिक बार अधिक तीव्र होगा।

— SpYk3HH

Answer 11

मैं बस एक और विकल्प साझा करना चाहता हूं, यह जरूरी नहीं है कि यहां दूसरों की तुलना में बेहतर है, लेकिन मुझे लगता है कि यह देखने लायक है:

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कार्य से बचना चाहते हैं तो उपयोगी हो सकता है ।

Answer 12

यदि आपका वातावरण ECMAScript 2015 का समर्थन करता है , तो आप Number.isNaNयह सुनिश्चित करने के लिए उपयोग कर सकते हैं कि मूल्य वास्तव में है NaN।

समस्या यह है isNaNकि, यदि आप गैर-संख्यात्मक डेटा का उपयोग करते हैं तो कुछ भ्रामक नियम हैं (एमडीएन के अनुसार)। उदाहरण के लिए,

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

तो, ECMA स्क्रिप्ट 2015 समर्थित वातावरण में, आप उपयोग करना चाह सकते हैं

Number.isNaN(parseFloat('geoff'))

Comments

मेरा वातावरण केवल ECMAScript XP होम संस्करण का समर्थन करता है :(

— पॉल डी। वेट

@ PaulD.Waite (मुझे उम्मीद है कि आपका मतलब IE 6: D) कोई समस्या नहीं है :-) बस याद रखें कि isNaNआप मुसीबत में पड़ सकते हैं और Number.isNaNECMAScript 2015 के वातावरण में उपयोग करने के लिए याद रखें :-)

— thefourtheye

Answer 13

जावास्क्रिप्ट में NaN का अर्थ "नॉट ए नंबर" है, हालांकि इसका प्रकार वास्तव में संख्या है।

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 है।

तो NNN () मदद नहीं कर सकता है। फिर इसके बदले हमें क्या करना चाहिए?

इस प्रकाश में कि 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

Answer 14

मैं अंडरस्कोरisNaN फ़ंक्शन का उपयोग करता हूं क्योंकि जावास्क्रिप्ट में:

isNaN(undefined) 
-> true

कम से कम, उस गोच के बारे में पता होना।

Comments

मैं उलझन में हूं। undefinedगलत व्यवहार होने पर NNN सही क्यों होगा ? यह सही है कि undefinedयह संख्या नहीं है, क्या यह नहीं है?

— Xaxis

@Xaxis NaN अपरिभाषित के बराबर नहीं माना जाना चाहिए, वे विशिष्ट और दोनों के साथ विशेष मान रहे हैं अलग अलग अर्थ। इस पर विचार करें: मेरे पास एक मूल्य है, लेकिन मैं यह नहीं बता रहा हूं कि यह क्या है, शायद यह एक संख्या है और शायद यह नहीं है, फिर भी, आपके दृष्टिकोण से, यह अपरिभाषित है।

— Corin

@Corin undefinedकुछ से अलग हो सकता है NaN, हालांकि यह अभी भी एक संख्या नहीं है, इसलिए isNaN(undefined)(और है)true

— neuhaus

Answer 15

शायद यह भी:

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

Answer 16

ऐसा लगता है कि NNN () बॉक्स से बाहर Node.js में समर्थित नहीं है।
मैंने साथ काम किया

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

Comments

ज़रूर, लेकिन मैं Node.js. के बारे में नहीं पूछ रहा था

— पॉल डी। वेट

Answer 17

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

Comments

मदद की सराहना !!

— जिमित रूपानी

Answer 18

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

इक्विटी ऑपरेटर (== और ===) का उपयोग NaN के विरुद्ध मान का परीक्षण करने के लिए नहीं किया जा सकता है।

पर देखो मोज़िला प्रलेखन वैश्विक NaN संपत्ति एक मूल्य के न-ए-कट्टरपंथी घुड़दौड़ का घोड़ा का प्रतिनिधित्व कर रहा है

सबसे अच्छा तरीका है NNNN () ’का उपयोग करना जो NaN की जाँच करने के लिए buit-in फ़ंक्शन है। सभी ब्राउज़र रास्ते का समर्थन करते हैं ।।

Answer 19

नियम है:

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

Answer 20

IEEE 754 के अनुसार, NaN को शामिल करने वाले सभी रिश्तों को छोड़कर! इस प्रकार, उदाहरण के लिए, (A> = B) = असत्य और (A <= B) = असत्य है यदि A या B या दोनों है / NaN।

Answer 21

मैंने StackOverflow पर एक अन्य प्रश्न का उत्तर लिखा NaN == nullथा, जहां एक और जाँच की गई थी, लेकिन तब इसे डुप्लिकेट के रूप में चिह्नित किया गया था, इसलिए मैं अपनी नौकरी बर्बाद नहीं करना चाहता।

को देखो मोज़िला डेवलपर नेटवर्क के बारे में NaN।

---

संक्षिप्त जवाब

distance || 0जब आप यह सुनिश्चित करना चाहते हैं कि आप उचित संख्या है या isNaN()इसे जांचना चाहते हैं तो बस उपयोग करें।

लंबा जवाब

NaN (Not-a-Number) जावास्क्रिप्ट में एक अजीब ग्लोबल ऑब्जेक्ट है जो कुछ गणितीय ऑपरेशन विफल होने पर अक्सर वापस आ जाता है।

आप जाँच करना चाहते थे कि NaN == nullकौन सा परिणाम है false। होवेवर के NaN == NaNसाथ भी परिणाम false।

यह पता लगाने का एक सरल तरीका है कि चर NaNएक वैश्विक फ़ंक्शन है isNaN()।

एक और है x !== x जो केवल तभी सत्य है जब x NaN है। (@ राफेल-स्कवीर्ट को याद दिलाने के लिए धन्यवाद)

लेकिन छोटा जवाब क्यों काम किया?

चलो पता करते हैं।

जब आप कॉल NaN == falseकरते हैं तो परिणाम falseउसी के साथ होता है NaN == true।

कहीं विशिष्टताओं में जावास्क्रिप्ट का रिकॉर्ड हमेशा गलत मूल्यों के साथ होता है, जिसमें शामिल हैं:

• NaN - नंबर नहीं
• "" - खाली स्ट्रिंग
• false - एक बूलियन झूठी
• null - अशक्त वस्तु
• undefined - अपरिभाषित चर
• 0 - संख्यात्मक 0, +0 और -0 सहित

Comments

"केवल यह पता लगाने का सरल तरीका है कि चर NaN एक वैश्विक कार्य है NNN () है" - सच नहीं है; एक और सरल तरीका है: var xIsNaN = x !== x;यह तभी सही होता है जब x है NaN।

— राफेल श्विकर्ट

Answer 22

एमडीएन के पार्सफ्लोट पेज में एक अन्य समाधान का उल्लेख किया गया है

यह सख्त पार्सिंग करने के लिए एक फिल्टर फंक्शन प्रदान करता है

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

Answer 23

जाँच करने का सही तरीका है:

//takes care of boolen, undefined and empty

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

Answer 24

मैंने यह छोटा सा फंक्शन बनाया है जो एक आकर्षण की तरह काम करता है। NaN के लिए जाँच करने के बजाय जो काउंटर सहज लगता है, आप एक नंबर के लिए जाँच करें। मुझे पूरा यकीन है कि मैं इस तरह से ऐसा करने वाला पहला नहीं हूं, लेकिन मुझे लगा कि मैं साझा करूंगा।

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

    return retval;
}

Answer 25

एक और रास्ता मिला, सिर्फ मनोरंजन के लिए।

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

Answer 26

markyzm का जवाब अच्छी तरह से काम करता है, लेकिन यह गलत नहीं है Infinityक्योंकि इन्फिनिटी techinicly एक नंबर नहीं है।

मैं एक 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));

Comments

आपका आधार अनंत है तकनीकी रूप से कोई संख्या तकनीकी रूप से त्रुटिपूर्ण नहीं है: math.stackexchange.com/questions/36289/is-infinity-a-number । उत्तरों के मेरे पढ़ने से यह है कि अनंत एक संख्या होने के नाते संदर्भ पर निर्भर करता है।

— जॉन पी।

मैं इसे दूसरे सवाल पर ले जा रहा हूँ

— adddff

Answer 27

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

यह सुरुचिपूर्ण नहीं है। लेकिन कोशिश करने के बाद NAN () मैं इस समाधान पर पहुंचा जो एक और विकल्प है। इस उदाहरण में मैंने भी अनुमति दी है। ' क्योंकि मैं नाव चला रहा हूं। आप यह भी उल्टा कर सकते हैं कि यह सुनिश्चित करने के लिए कि कोई संख्या उपयोग नहीं की जाती है।

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

यह एक एकल वर्ण मूल्यांकन है, लेकिन आप किसी भी संख्या की जांच करने के लिए स्ट्रिंग के माध्यम से लूप कर सकते हैं।

Answer 28

आप NaN जावास्क्रिप्ट फ़ंक्शन का उपयोग करके NaN की जाँच कर सकते हैं। बस isna फ़ंक्शन को संख्या या मान पास करना

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

Answer 29

बस परिणाम को स्ट्रिंग में परिवर्तित करें और 'NaN' के साथ तुलना करें।

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

Answer 30

है (NaN> = 0) ? ...... " मुझे नहीं पता "।

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

यदि केवल TRUE हो तो स्थितियां निष्पादित होती हैं ।

FALSE पर नहीं ।

" आई डोंट नो " पर नहीं ।

Comments

बहुत उपयोगी नहीं है यदि आप स्पष्ट रूप से NaN मूल्यों की तलाश में हैं, तो विपरीत की तलाश में हैं

— liviu blidar