ฉันลองใช้ในคอนโซล 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 Type จะถูกทดสอบว่าเป็น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 เท่านั้นและเป็นวิธีที่ปลอดภัยในการทดสอบ ควรถูกห่อหุ้มด้วยฟังก์ชั่นหรือ atleast อย่างแน่นอนเพราะมันไม่สมเหตุสมผลมากนักในการทดสอบว่าตัวแปรเดียวกันไม่เท่ากับกันเหรอ

คุณควรใช้การisNaN(value)เรียกฟังก์ชันทั่วโลกเพราะ:

• ได้รับการสนับสนุนข้ามเบราว์เซอร์
• ดูisNaNสำหรับเอกสารประกอบ

ตัวอย่าง:

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

ฉันหวังว่านี่จะช่วยคุณได้

ในฐานะของES6 , Object.is(..)เป็นอาคารใหม่ที่สามารถนำมาใช้ในการทดสอบสองค่าเพื่อความเท่าเทียมกันแน่นอน:

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

หากต้องการแก้ไขปัญหาที่'1.2geoff'จะแยกวิเคราะห์ให้ใช้Number()parser แทน

ดังนั้นมากกว่านี้

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

เพื่อให้ชัดเจนฉันจะดูแลการแปลความหมายตามตัวอักษรของมนุษย์ในสิ่งที่เป็น "Not a Number" และ Lodash จะดูแลคอมพิวเตอร์การตีความตามตัวอักษรของการตรวจสอบว่ามีอะไรบางอย่าง "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()แต่ต้องระวัง gotcha ด้วยตัวเลขที่เชื่อมโยงกับอักขระที่ไม่ใช่ตัวเลขเพิ่มเติม

ทางออกที่ง่าย!

ง่ายมากจริงๆ! ที่นี่! มีวิธีนี้!

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

ใช้ง่ายเหมือน:

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

ดูการทดสอบประสิทธิภาพhereโดยใช้ func vsselected 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>

มีเส้นทางสำรองสองทางที่คุณใช้สำหรับ implementaion หากคุณไม่ต้องการใช้วิธีการตั้งชื่อแบบอื่นและต้องการให้แน่ใจว่ามันมีอยู่ทั่วโลกมากกว่า คำเตือนวิธีแก้ไขปัญหาเหล่านี้เกี่ยวข้องกับการดัดแปลงวัตถุดั้งเดิมและอาจไม่ใช่วิธีที่ดีที่สุดของคุณ ใช้ความระมัดระวังและพึงระวังว่าไลบรารี่อื่นที่คุณอาจใช้ขึ้นอยู่กับรหัสเนทีฟหรือการเปลี่ยนแปลงที่คล้ายกัน

การใช้งานสำรอง 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 ย่อมาจาก "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

มันสมเหตุสมผลแล้วเพราะ "A" ไม่ใช่ตัวเลข แต่สิ่งที่เราต้องการตรวจสอบจริงๆคือ myVar นั้นมีคุณค่าอย่างแท้จริงหรือไม่

ดังนั้น isNaN () ไม่สามารถช่วยได้ ถ้าอย่างนั้นเราควรทำอะไรแทน

ในแง่ที่ว่า NaN เป็นค่าจาวาสคริปต์เพียงอย่างเดียวที่ได้รับการปฏิบัติที่ไม่เท่าเทียมกับตัวเองดังนั้นเราสามารถตรวจสอบความเท่าเทียมกันกับตัวเองโดยใช้! ==

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

อย่างน้อยก็ต้องระวัง gotcha นั่นด้วย

อาจจะยังนี้:

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 Documentation คุณสมบัติ NaN ส่วนกลางเป็นค่าที่แสดงถึง Not-A-Numbe

วิธีที่ดีที่สุดคือใช้ 'isNaN ()' ซึ่งเป็นฟังก์ชัน buit-in เพื่อตรวจสอบ 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) เป็น Weirdo Global Object ในจาวาสคริปต์ที่ส่งคืนบ่อยครั้งเมื่อการดำเนินการทางคณิตศาสตร์บางอย่างล้มเหลว

คุณต้องการตรวจสอบว่าNaN == nullผลลัพธ์falseใด Hovewer แม้จะส่งผลกับNaN == NaNfalse

วิธีง่ายๆในการตรวจสอบว่าตัวแปรเป็นNaNฟังก์ชันสากลisNaN()หรือไม่

อีกอย่างคือ x !== xซึ่งเป็นจริงเฉพาะเมื่อ x คือ NaN (ขอบคุณที่เตือนให้ @ @ raphael-schweikert)

แต่ทำไมคำตอบสั้น ๆ ใช้งานได้?

มาหาคำตอบกัน

เมื่อคุณเรียกNaN == falseผลที่ได้คือเดียวกันกับfalseNaN == true

บางแห่งในข้อกำหนด JavaScript มีบันทึกที่มีค่าเท็จเสมอซึ่งรวมถึง:

• NaN - ไม่ใช่ -a-Number
• "" - สตริงว่าง
• false - บูลีนเท็จ
• null - วัตถุ 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);  
}

คำตอบของ markyzm ทำงานได้ดี แต่ไม่ส่งกลับค่าเท็จ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"));

UPDATE: ฉันสังเกตเห็นว่าโค้ดนี้ล้มเหลวสำหรับพารามิเตอร์บางตัวดังนั้นฉันจึงทำให้ดีขึ้น

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 โดยใช้ฟังก์ชั่น isNaN 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

เพียงแปลงผลลัพธ์เป็นสตริงและเปรียบเทียบกับ '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;
}

เงื่อนไขเพียงดำเนินการถ้าTRUE

ไม่ได้อยู่ในFALSE

ไม่ได้อยู่ที่ " ฉันไม่รู้ "