487

我只在 Firefox 的 JavaScript 控制台中尝试过,但以下语句均未返回 true:

parseFloat('geoff') == NaN;

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

32 回答 32

666

试试这个代码:

isNaN(parseFloat("geoff"))

要检查任何值是否为 NaN,而不仅仅是数字,请参见此处:如何在 Javascript 中测试 NaN?

于 2010-04-16T10:58:04.793 回答
167

我刚刚在《 Effective 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

于 2013-06-07T16:05:06.610 回答
59

使用此代码:

isNaN('geoff');

请参阅isNaN()MDN 上的文档

alert ( isNaN('abcd'));  // alerts true
alert ( isNaN('2.0'));  // alerts false
alert ( isNaN(2.0));  // alerts false
于 2010-04-16T10:59:31.330 回答
49

至于要测试Number类型的值是否为 a 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;
}

请查看此答案以获取更多详细信息。

于 2015-08-21T10:11:38.663 回答
18

ES6开始,Object.is(..)是一个新的实用程序,可用于测试两个值的绝对相等性:

var a = 3 / 'bar';
Object.is(a, NaN); // true
于 2015-12-28T03:26:53.493 回答
17

您应该使用全局isNaN(value)函数调用,因为:

  • 支持跨浏览器
  • 有关文档,请参见isNaN

例子:

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

我希望这能帮到您。

于 2010-04-16T10:57:34.920 回答
17

NaN 是一个特殊的值,不能这样测试。我只想分享的一件有趣的事情是

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

这仅对NaN 值返回 true ,并且是一种安全的测试方式。绝对应该被包裹在一个函数中或者至少被注释掉,因为测试同一个变量是否不相等显然没有多大意义,呵呵。

于 2013-01-08T17:27:11.990 回答
11

JavaScript 中的 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

这实际上是有道理的,因为“A”实际上不是数字。但我们真正想要检查的是 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
于 2017-09-09T08:40:40.913 回答
10

要解决'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

编辑:我只是注意到了另一个问题... false 值(并且 true 作为真正的布尔值)传递给Number()return as 0!在这种情况下... parseFloat 每次都有效。所以回到那个:

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

这似乎涵盖了一切。我对它进行了基准测试,它比 lodash 慢 90%,_.isNaN但是那个并没有涵盖所有的 NaN:

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

为了清楚起见,我的负责人对“非数字”的字面解释,而 lodash 负责检查某事物是否为“NaN”的计算机字面解释。

于 2014-03-17T10:57:10.237 回答
8

虽然@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(),但要注意数字与其他非数字字符交织在一起的问题。

于 2013-08-24T23:08:25.747 回答
6

简单的解决方案!

真的超级简单!这里!有这个方法!

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

使用简单:

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

查看here使用此函数的性能测试 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>

如果您不想使用交替命名的方法,并且希望确保它在全球范围内更可用,那么您可以采用几种替代路径来实现。警告这些解决方案涉及更改本机对象,可能不是您的最佳解决方案。请务必谨慎使用,并注意您可能使用的其他库可能依赖于本机代码或类似的更改。

替代实现 1:替换 NativeisNaN方法。

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

替代实现 2:附加到数字对象
*建议,因为它也是 ECMA 5 到 6 的 polyfill

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

如果为空,则替代解决方案测试

我编写了一个简单的窗口方法来测试 object 是否为Empty有点不同的是,如果 item 是“完全” 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>

于 2015-01-21T12:53:26.443 回答
6

规则是:

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"))
于 2019-02-16T06:26:52.630 回答
6

如果您的环境支持 ECMAScript 2015,那么您可能需要使用Number.isNaN来确保该值是真的NaN.

问题isNaN是,如果您将其与非数字数据一起使用,则几乎不会应用令人困惑的规则(根据 MDN)。例如,

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

因此,在 ECMA Script 2015 支持的环境中,您可能希望使用

Number.isNaN(parseFloat('geoff'))
于 2015-08-14T15:32:09.603 回答
5

我使用下划线isNaN函数是因为在 JavaScript 中:

isNaN(undefined) 
-> true

至少,要注意那个问题。

于 2012-10-18T19:38:46.913 回答
5

我只是想分享另一种选择,它不一定比这里的其他人更好,但我认为它值得一看:

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功能,可能会变得有用。

于 2014-03-20T14:13:11.077 回答
5

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

于 2017-08-30T05:26:05.130 回答
4

也许还有这个:

function isNaNCustom(value){
    return value.toString() === 'NaN' && 
           typeof value !== 'string' && 
           typeof value === 'number'
}
于 2018-02-01T13:30:50.560 回答
4

isNaN() 函数确定一个值是否为 NaN。因为 isNaN 函数内部的强制转换可能令人惊讶,所以您也可以使用 Number.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
isNaN(null) //false

isNaN 函数的便利性 与 JavaScript 中所有其他可能的值不同,不可能使用等式运算符(== 和 ===)将值与 NaN 进行比较以确定该值是否为 NaN,因为两者都是 NaN == NaN 和 NaN === NaN 评估为假。isNaN() 函数为 NaN 提供了方便的相等性检查。

于 2021-09-15T13:26:31.353 回答
3

开箱即用的 Node.js 似乎不支持 isNaN() 。
我和我一起工作

var value = 1;
if (parseFloat(stringValue)+"" !== "NaN") value = parseFloat(stringValue);
于 2013-05-06T09:05:15.647 回答
3
NaN === NaN;        // false
Number.NaN === NaN; // false
isNaN(NaN);         // true
isNaN(Number.NaN);  // true

等式运算符(== 和 ===)不能用于针对 NaN 测试值。

查看Mozilla 文档全局 NaN 属性是一个代表 Not-A-Numbe 的值

最好的方法是使用内置函数“isNaN()”来检查 NaN。所有浏览器都支持的方式..

于 2014-11-08T22:18:25.623 回答
2

根据 IEEE 754,所有涉及 NaN 的关系都评估为假,除了 !=。因此,例如,如果 A 或 B 或两者都是 NaN,则 (A >= B) = false 和 (A <= B) = false。

于 2014-10-28T20:09:04.637 回答
2

MDN 的 parseFloat 页面中提到了另一种解决方案

它提供了一个过滤器功能来做严格的解析

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

于 2016-05-04T17:22:36.257 回答
2

找到了另一种方式,只是为了好玩。

function IsActuallyNaN(obj) {
  return [obj].includes(NaN);  
}
于 2017-05-19T04:43:00.567 回答
2

我在StackOverflow上为另一个问题写了这个答案,另一个问题是什么时候检查,NaN == null然后它被标记为重复,所以我不想浪费我的工作。

查看Mozilla 开发者网络关于NaN.


简短的回答

只需distance || 0在您想确定您的值是一个正确的数字或isNaN()​​检查它时使用。

长答案

NaN(非数字)是 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
于 2015-11-30T06:47:16.143 回答
0

确切的检查方法是:

//takes care of boolen, undefined and empty

isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number'
于 2016-05-30T04:25:53.087 回答
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
于 2021-07-01T20:12:12.083 回答
0

我创建了这个像魅力一样工作的小功能。与其检查似乎违反直觉的 NaN,不如检查一个数字。我很确定我不是第一个这样做的人,但我想我会分享。

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

    return retval;
}
于 2016-06-05T20:14:33.667 回答
0

markyzm 的答案效果很好,但它不会返回 false,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));

于 2017-06-09T01:11:00.487 回答
0
alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);

这并不优雅。但是在尝试了 isNAN() 之后,我找到了这个解决方案,这是另一种选择。在这个例子中,我还允许使用 '.' 因为我正在掩盖浮动。您也可以将其反转以确保不使用任何数字。

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

这是一个单字符评估,但您也可以遍历一个字符串来检查任何数字。

于 2017-08-16T19:38:10.180 回答
-1

(NaN >= 0)吗?......“我不知道”。

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

条件仅在TRUE时执行。

不在FALSE上。

不在“我不知道”。

于 2017-09-18T21:57:22.180 回答
-1

所以我看到了一些对此的回应,

但我只是使用:

function isNaN(x){
     return x == x && typeof x == 'number';
}
于 2017-12-18T22:57:38.333 回答
-1

只需将结果转换为字符串并与“NaN”进行比较。

var val = Number("test");
if(String(val) === 'NaN') {
   console.log("true");
}
于 2017-02-23T11:17:07.840 回答