[英]How do you check that a number is NaN in JavaScript?
我只是在 Firefox 的 JavaScript 控制台中尝试过,但以下语句均未返回 true:
parseFloat('geoff') == NaN;
parseFloat('geoff') == Number.NaN;
我刚刚在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
使用此代码:
isNaN('geoff');
请参阅MDN 上的isNaN()
文档。
alert ( isNaN('abcd')); // alerts true
alert ( isNaN('2.0')); // alerts false
alert ( isNaN(2.0)); // alerts false
至于要测试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 和 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;
}
请查看此答案以获取更多详细信息。
从ES6 开始, Object.is(..)
是一个新的实用程序,可用于测试两个值的绝对相等性:
var a = 3 / 'bar';
Object.is(a, NaN); // true
NaN 是一个特殊的值,不能像那样测试。 我只想分享一个有趣的事情是这个
var nanValue = NaN;
if(nanValue !== nanValue) // Returns true!
alert('nanValue is NaN');
这仅对NaN 值返回 true 并且是一种安全的测试方式。 肯定要包裹在一个函数中或者至少注释掉,因为测试同一个变量是否不相等显然没有多大意义,呵呵。
您应该使用全局isNaN(value)
函数调用,因为:
例子:
isNaN('geoff'); // true
isNaN('3'); // false
我希望这能帮到您。
要解决解析'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()
错误值(和真正的布尔值Number()
返回为0
! 在这种情况下...... parseFloat 每次都有效。 所以回到那个:
function definitelyNaN (val) {
return isNaN(val && val !== true ? Number(val) : parseFloat(val));
}
这几乎涵盖了一切。 我以比 lodash 的_.isNaN
慢 90% 的速度对其进行了基准测试,但是那个并没有涵盖所有的 NaN:
http://jsperf.com/own-isnan-vs-underscore-lodash-isnan
为了清楚起见,我的负责人对“非数字”的字面解释,而 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()
包装它,但要注意数字与其他非数字字符交织在一起的问题.
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
真的超级简单! 这里! 有这个方法!
function isReallyNaN(a) { return a !== a; };
使用简单如:
if (!isReallyNaN(value)) { return doingStuff; }
另外:请参阅下面的第一个示例以了解几个替代实现。
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)
替代解决方案测试是否为空
我编写了一个简单的窗口方法来测试对象是否为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>
如果您的环境支持 ECMAScript 2015 ,那么您可能需要使用Number.isNaN
来确保该值确实是NaN
。
isNaN
的问题是, 如果您将其与非数字数据一起使用,则几乎不会应用令人困惑的规则(根据 MDN)。 例如,
isNaN(NaN); // true
isNaN(undefined); // true
isNaN({}); // true
因此,在 ECMA Script 2015 支持的环境中,您可能希望使用
Number.isNaN(parseFloat('geoff'))
我只是想分享另一种选择,它不一定比这里的其他人更好,但我认为值得一看:
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
函数,可能会很有用。
function isNotANumber(n) { if (typeof n !== 'number') { return true; } return n !== n; }
规则是:
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"))
也许还有这个:
function isNaNCustom(value){
return value.toString() === 'NaN' &&
typeof value !== 'string' &&
typeof value === 'number'
}
开箱即用的 Node.js 似乎不支持 isNaN() 。
我曾与
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 文档全局 NaN 属性是一个表示 Not-A-Numbe 的值
最好的方法是使用'isNaN()',它是检查NaN 的内置函数。 所有浏览器都支持的方式..
根据 IEEE 754,除 != 外,所有涉及 NaN 的关系都评估为假。 因此,例如,如果 A 或 B 或两者都是 NaN,则 (A >= B) = false 和 (A <= B) = false。
我在StackOverflow上的另一个问题上写了这个答案,其中另一个检查何时NaN == null
但随后它被标记为重复,所以我不想浪费我的工作。
查看关于NaN
Mozilla 开发者网络。
只需使用distance || 0
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
- 布尔值 falsenull
- 空对象undefined
- 未定义的变量0
- 数字 0,包括 +0 和 -0MDN的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
找到了另一种方式,只是为了好玩。
function IsActuallyNaN(obj) {
return [obj].includes(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;
}
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));
alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);
这并不优雅。 但是在尝试 isNAN() 之后,我找到了这个解决方案,这是另一种选择。 在这个例子中,我也允许 '.' 因为我正在掩盖浮动。 您也可以将其反转以确保不使用数字。
("1234567890".indexOf(String.fromCharCode(mycharacter))==-1)
这是一个单字符评估,但您也可以遍历字符串以检查任何数字。
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
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 的方便的相等性检查。
在条件下尝试两者
if(isNaN(parseFloat('geoff')) && typeof(parseFloat('geoff')) === "number");
//true
发现这很有用
// Long-hand const isFalsey = (value) => { if (
value === null ||
value === undefined ||
value === 0 ||
value === false ||
value === NaN ||
value === "" ) {
return true; } return false; };
// Short-hand const
isFalsey = (value) => !value;
只需将结果转换为字符串并与“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 。
不是“我不知道”。
所以我看到了几个对此的回应,
但我只是使用:
function isNaN(x){
return x == x && typeof x == 'number';
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.