我只是在Firefox的JavaScript控制台中尝试过，但以下两个语句都没有返回true：
parseFloat('geoff') == NaN;
parseFloat('geoff') == Number.NaN;
答案 0 :(得分：525)
试试这段代码：
isNaN(parseFloat("geoff"))
要检查任何值是否为NaN，而不仅仅是数字，请参阅此处：How do you test for NaN in Javascript?
答案 1 :(得分：131)
我刚才在Effective JavaScript一书中遇到过这种非常简单的技巧：
由于NaN是唯一被视为不等于自身的JavaScript值，因此您可以通过检查值是否为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
在@allsyed发表评论之前没有意识到这一点，但这符合ECMA规范：https://tc39.github.io/ecma262/#sec-isnan-number
答案 2 :(得分：49)
使用此代码：
isNaN('geoff');
alert ( isNaN('abcd')); // alerts true
alert ( isNaN('2.0')); // alerts false
alert ( isNaN(2.0)); // alerts false
答案 3 :(得分：40)
如果要测试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＆amp; 6，我们也可以使用这个polyfill for 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;
}
请查看This Answer了解详情。
答案 4 :(得分：16)
NaN是一个特殊值，无法像这样进行测试。我只想分享一个有趣的事情是
var nanValue = NaN;
if(nanValue !== nanValue) // Returns true!
alert('nanValue is NaN');
这为NaN值返回true ，是一种安全的测试方法。绝对应该包含在一个函数中或至少被评论过，因为测试相同的变量是否彼此不相等显然没有多大意义，呵呵。
答案 5 :(得分：14)
您应该使用全局isNaN(value)函数调用，因为：
示例：
isNaN('geoff'); // true
isNaN('3'); // false
我希望这会对你有所帮助。
答案 6 :(得分：12)
从 ES6 开始，Object.is(..)是一个新的实用程序，可用于测试两个绝对相等的值：
var a = 3 / 'bar';
Object.is(a, NaN); // true
答案 7 :(得分：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的假值（和真实的布尔值一样）返回function definitelyNaN (val) {
return isNaN(val && val !== true ? Number(val) : parseFloat(val));
}
！在这种情况下... parseFloat每次都有效。所以回过头来看：
_.isNaN这涵盖了看似一切。我对它的基准测试比lodash的{{1}}慢了90％但是那个并没有覆盖所有的NaN：
http://jsperf.com/own-isnan-vs-underscore-lodash-isnan
为了清楚起见，我处理了对“非数字”的人类字面解释，并且lodash负责检查是否有某些东西是“NaN”的计算机文字解释。
答案 8 :(得分：7)
虽然@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()包裹它，但要注意与数字交织在一起的问题其他非数字字符。
答案 9 :(得分：6)
非常简单！这里！有这种方法！
function isReallyNaN(a) { return a !== a; };
使用简单：
if (!isReallyNaN(value)) { return doingStuff; }
See performance test here使用此func vs 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>
如果您不想使用交替命名的方法，并且希望确保它更具全局可用性，那么您可以采用另外几种方法来实施。 警告 这些解决方案涉及更改本机对象，可能不是您的最佳解决方案。请务必小心谨慎，并注意您可能使用的其他库可能依赖于本机代码或类似的更改。
isNaN方法。// Extremely simple. Just simply write the method.
window.isNaN = function(a) { return a !==a; }
Number['isNaN'] || (Number.isNaN = function(a) { return a !== a });
// Use as simple as
Number.isNaN(NaN)
替代解决方案测试是否为空
我写的一个简单的窗口方法，测试对象是 空 。它有点不同之处在于，如果项目＆＃34;确切地说＆＃34;它没有给出。 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>
答案 10 :(得分：5)
如果您的环境支持ECMAScript 2015 ，那么您可能希望使用Number.isNaN来确保该值真的为infinity。
isNaN的问题是，if you use that with non-numeric data there are few confusing rules (as per MDN) are applied.例如，
NaN因此，在ECMA Script 2015支持的环境中，您可能希望使用
isNaN(NaN); // true
isNaN(undefined); // true
isNaN({}); // true
答案 11 :(得分：4)
答案 12 :(得分：4)
JavaScript中的NaN代表＆＃34;非数字＆＃34;，尽管其类型实际上是数字。
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
这实际上是有道理的，因为＆＃34; A＆＃34;实际上不是一个数字。但我们真正想要检查的是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
答案 13 :(得分：4)
我只是想分享另一种选择，它不一定比其他人更好，但我认为值得关注：
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功能，可能会有用。
答案 14 :(得分：3)
function isNotANumber(n) {
if (typeof n !== 'number') {
return true;
}
return n !== n;
}
答案 15 :(得分：3)
开箱即用的Node.js似乎不支持isNaN（）
我一直在努力var value = 1;
if (parseFloat(stringValue)+"" !== "NaN") value = parseFloat(stringValue);
答案 16 :(得分：2)
NaN === NaN; // false
Number.NaN === NaN; // false
isNaN(NaN); // true
isNaN(Number.NaN); // true
等式运算符（==和===）不能用于测试针对NaN的值。
查看Mozilla Documentation The global NaN property is a value representing Not-A-Numbe
最好的方法是使用'isNaN（）'，它是用于检查NaN的buit-in函数。所有浏览器都支持这种方式..
答案 17 :(得分：2)
检查的确切方法是：
//takes care of boolen, undefined and empty
isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number'
答案 18 :(得分：2)
也许这个：
function isNaNCustom(value){
return value.toString() === 'NaN' &&
typeof value !== 'string' &&
typeof value === 'number'
}
答案 19 :(得分：1)
您可以使用isNaN javascript函数检查NaN。只需将数字或值传递给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
答案 20 :(得分：1)
规则是：
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"))
答案 21 :(得分：1)
（NaN> = 0）？......＆＃34; 我不知道＆＃34;。
function IsNotNumber( i ){
if( i >= 0 ){ return false; }
if( i <= 0 ){ return false; }
return true;
}
条件仅在 TRUE 时执行。
不在 FALSE 。
不在＆＃34; 我不知道＆＃34;。
答案 22 :(得分：1)
我在StackOverflow上写了另一个问题的答案，其中另一个问题在NaN == null时检查，但后来又标记为重复，所以我不想浪费我的工作。
关于NaN，请Mozilla Developer Network。
如果您想确定您的值是正确的数字还是distance || 0来检查它，请使用isNaN()。
NaN（Not-a-Number）是javascript中的怪异全局对象，在某些数学运算失败时经常返回。
您想检查NaN == null是否会产生false。 Hovewer甚至NaN == NaN会产生false。
找出变量NaN的简单方法是全局函数isNaN()。
另一个是x !== x，只有当x是NaN时才是真的。 （感谢提醒@ raphael-schweikert）
让我们找出答案。
当您致电NaN == false时，结果为false，与NaN == true相同。
规范中的某处JavaScript具有始终为false值的记录，其中包括：
NaN - 非数字"" - 空字符串false - 布尔值假null - null object undefined - 未定义的变量0 - 数字0，包括+0和-0 答案 23 :(得分：1)
alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);
这不优雅。但是在尝试了isNAN（）后，我找到了这个解决方案，这是另一种选择。在这个例子中，我也允许＆＃39;。＆＃39;因为我正在掩饰浮动。您也可以将其反转以确保不使用任何数字。
("1234567890".indexOf(String.fromCharCode(mycharacter))==-1)
这是单个字符评估，但您也可以遍历字符串以检查任何数字。
答案 24 :(得分：1)
marksyzm的答案效果很好，但Infinity并没有返回false，因为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));
答案 25 :(得分：1)
找到另一种方式，只是为了好玩。
function IsActuallyNaN(obj) {
return [obj].includes(NaN);
}
答案 26 :(得分：1)
我创造了这个像魅力一样的小功能。 您可以检查一个数字，而不是检查看似反直觉的NaN。我很确定我不是第一个这样做的人，但我想我会分享。
setlocal EnableDelayedExpansion
for /f "tokens=2 delims==" %%z in (from.txt) do (
set resulta=%%z
)
for /f "delims=" %%x in (workwith.txt) do (
set _alla=%%x
set _firstcombine=!_alla:8150=%resulta%!
echo _firstcombine >> move1.txt
)
for /f "tokens=* delims=" %%v in ('findstr /C:"2016" from.txt') do (
set _result=%%v
set _outp=!_result:~52!
)
for /f "delims=" %%f in ('findstr /C:"2016" move1.txt') do (
set _allz=%%f
set _txo=!_all:~170,-255!
set _secondcombine=!_allz:%_txo%=%_outp%!
echo _secondcombine >> move2.txt
)
for /f "tokens=* delims=" %%j in ('findstr /C:"Wanaka," from.txt') do (
set _resultn=%%j
)
for /f "delims=" %%l in ('findstr /C:"xxx" move2.txt') do (
set _allf=%%l
set _to=!_all:~52!
set _thirdcombine=!_allf:%_to%=%_resultn%!
echo _thirdcombine >> move3.txt
)
pause
答案 27 :(得分：1)
它提供了一个过滤函数来进行严格的解析
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
答案 28 :(得分：1)
根据IEEE 754，除了！=之外，涉及NaN的所有关系都被评估为假。因此，例如，如果A或B或两者都是NaN，则（A> = B）=假并且（A <= B）=假。
答案 29 :(得分：0)
Number('hello').toString() === 'NaN' // true
Number(undefined).toString() === 'NaN' // true
Number('12345').toString() === 'NaN' // false
// These all evaluate to 0 which is a number
Number('').toString() === 'NaN' // false // 0
Number('0').toString() === 'NaN' // false // 0
Number().toString() === 'NaN' // false // 0
// These all evaluate to 0 and 1 which is a number
Number(false).toString() === 'NaN' // false // 0
Number(true).toString() === 'NaN' // false // 1
答案 30 :(得分：-1)
所以我看到了几个回应，
但我只是使用：
function isNaN(x){
return x == x && typeof x == 'number';
}