如何检查JavaScript中的数字是否为NaN？

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

parseFloat('geoff') == NaN;

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

如果您的实际目标是检查数字，则值得阅读：stackoverflow.com/questions/18082/…

designpepper.com/blog/drips/…

@Gothdo：可以，但是我确实问过如何检查数字是否为NaN而不是任何值。

@ PaulD.Waite是的，但是在搜索诸如“如何检查javascript中的变量是否为nan”之类的内容时，会有很多人来这里。

PaulD.Waite我同意你的看法，但我和@Gothdo一样担心。许多人以“如何检查JS中的值是否为NaN”的意图着手解决此问题。您可以检查mjohnsonengr对同一答案的评论。顺便说一句，我也已经标记了这个问题，以引起版主的注意。

#1 楼

尝试以下代码：

isNaN(parseFloat("geoff"))

要检查是否有任何值是NaN而不是数字，请参见此处：如何在Javascript中测试NaN？

是否需要paseFloat？

–rahul
10-4-16在11:02

如果要将空字符串解释为NaN，则可以。（我并不是说你总是会的。）

– Paul D. Waite
2010-4-16的12:20

如果我是我，我会将其分配给变量，然后使用条件变量！== variable。如规格书tc39.github.io/ecma262/#sec-isnan-number中所述

– Allsyed
16年7月11日在5:43

isNaN（parseFloat（“ geoff”））// true isNaN（parseFloat（“ 10geo”））// false这有什么用？

– Prashanth
19年2月7日在10:12

这对于尝试w3schools.com/jsref/jsref_isnan.asp也是有用的

–斯里兰卡乔杜里
1月14日4:10

#2 楼

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

有效，但违反直觉。我不想维护这种代码。

–谢尔盖·奥尔山斯基（Sergey Orshanskiy）
2014年4月20日在7:28

违反直觉的不是代码，而是NaN。

–爵士乐
2014年5月15日17:47

@DanM不是错误，这是NaN的标准IEE754行为。它是在CPU中实现的方式，也是世界上使用浮点数的每种编程语言的预期行为。

–塔米尔
2014年7月30日在10:16

@Tarmil Duly指出了！实际上，这真的很有趣。我一直认为NaN不等式怪异是Java语言。

– Dan M
14年8月6日在21:03

NaN === Nan; //错误。这是javascript中的已知错误。 isNan是一种新方法。

–阿蒂尔坎
17年12月31日在12:36

#3 楼

使用此代码：

isNaN('geoff');

请参阅isNaN() MDN上的文档。

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

也许只有我一个人，但是当var value = 0/0;时，NaN的概念变得令人困惑。和var value2 = String（“ 123 131”）;创建NaN值和类似这样的值var value3 =“ abcd”;也是一个NaN值。

–尼克·皮内达（Nick Pineda）
16年3月11日在5:50

@NickPineda为什么？

–辛加
19年2月14日在19:11

#4 楼

至于是否要测试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;
}

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

感谢您不仅使用“ isNan（）”，而且还提供了完整的详细答案。这正是我在Google上发现此问题时要寻找的东西。

–mjohnsonengr
15年11月19日在21:16

“ ...在上述情况下给出了错误的结果”我不会说错，只是有所不同，因为全局isNaN首先将参数转换为数字值。

–费利克斯·克林（Felix Kling）
16-3-7在7:23

@FelixKling请检查更新的答案。谢谢。

– dopeddude
16 Mar 7 '16 at 7:53

isNaN（“ lorem ipsum”）; // ES5的真实让我震惊

–尼克·皮内达（Nick Pineda）
16 Mar 10 '16 at 5:36

@NickPineda这种感觉是如此共同，但是最终MDN可以这样解释：“当isNaN函数的参数不是Number类型时，该值首先被强制为Number。然后测试结果值以确定它是否为NaN。”

– dopeddude
16 Mar 10 '16 at 9:08

#5 楼

NaN是一个无法像这样测试的特殊值。我只想分享一个有趣的事情，这是

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

这仅对NaN值返回true，是一种安全的测试方法。绝对应该将其包装在函数中或至少添加注释，因为测试同一个变量是否彼此相等显然没有多大意义，嘿嘿。

那不是一个完全可靠的方法。根据规格。变量！==变量是检查NaN的最可靠方法

– Allsyed
16年7月11日在5:39

看到我在上面的答案^

–爵士乐
17年4月26日在23:14

#6 楼

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

跨浏览器受支持
有关文档，请参见isNaN

示例：

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

希望对您有所帮助。

是的，isNaN（''）// false，但parseInt（''）// NaN。可以说是null。

–静音企鹅
13年5月1日14:14

#7 楼

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

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

MDN的NaN文档

– Robsch
19年7月8日在11:23

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

这似乎涵盖了所有内容。我将其基准测试的速度比lodash的_.isNaN慢90％，但后来它没有涵盖所有的NaN：

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

只需清楚一点，我的代码将对“ Not a Number”（非数字）进行人类文字解释，而lodash的代码将对计算机进行文字解释，以检查某些事物是否为“ NaN”。

#9 楼

尽管@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()包裹在一起，但要注意数字相互交织的陷阱带有其他非数字字符。

有趣。有什么办法可以解决这个问题，并检测到“ 1.2geoff”实际上不是有效的数字字符串吗？

–Gabe Halsmer
13年11月29日在23:01

请注意，仅当字符串以数字开头时，才会发生这种情况。 parseFloat（'test1.2'）将返回NaN。

–爱德华·卢卡（Eduard Luca）
2014年7月8日在9:26

#10 楼

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

#11 楼

如果您的环境支持ECMAScript 2015，则可能需要使用Number.isNaN来确保该值确实为NaN。

isNaN的问题是，如果将其与非数值数据一起使用，则问题很少应用了混乱的规则（按照MDN）。例如，

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

因此，在ECMA Script 2015支持的环境中，您可能想使用

Number.isNaN(parseFloat('geoff'))

我的环境仅支持ECMAScript XP Home Edition ：（

– Paul D. Waite
15年8月14日在15:51

@ PaulD.Waite（我希望您的意思是IE 6：D）没问题:-)请记住isNaN可能会给您带来麻烦，并记得在ECMAScript 2015环境中使用Number.isNaN :-)

–thefourtheye
15年8月14日在15:53

#12 楼

简单的解决方案！

真的超级简单！这里！使用此方法！

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

使用简单，方法如下：

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

查看性能测试在这里使用此func vs选择的答案

另外：请参见下面的第一个示例，了解几个替代实现。

示例：

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

var example = {
    'NaN': NaN,
    'an empty Objet': {},
    'a parse to NaN': parseFloat('.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('.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('.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>

@ PaulD.Waite也许是这个应用程序，但我没有看到可接受的答案。实际上，我只看到大约5个答案，但我看到它说有15个答案

– SpYk3HH
15年1月21日在13:06

您正在使用什么应用程序？

– Paul D. Waite
15年1月21日在14:18

@ PaulD.Waite SE安卓版。在银河S3上

– SpYk3HH
2015年1月21日14:28

啊哈我没有让我自己看的应用程序，但这是指向可接受答案的链接：stackoverflow.com/a/2652335/20578

– Paul D. Waite
15年1月21日在15:01

@ PaulD.Waite啊，我明白了。我想，仅对问题本身直接回答，就可以解决。因为isNaN不可靠，所以我在另一个问题上总共贴出了与“检查JS的NaN的方式”完全相同的答案。我在那里被评论，并告诉这个问题更适合我的答案，因此将其移到此处。只需在此问题上针对此问题提供一些有用/有用的信息，就会出现在Google对当前问题的搜索中，这是NaN吗？附带一提，我的答案会比选定答案更准确。

– SpYk3HH
15年1月21日在15:18

#13 楼

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

isNaN(undefined) 
-> true

至少要注意该陷阱。

我很困惑。为什么NaN在传递未定义时返回true是不正确的行为？确实，undefined不是数字，不是吗？

– Xaxis
13年2月2日在18:05

@Xaxis NaN不应被视为等同于undefined，它们都是具有特定含义和不同含义的特殊值。考虑一下：我有一个值，但我没有告诉它是什么，也许这是一个数字，但是从您的角度来看，它不是一个未定义的值。

–科林
2014年3月20日13:40

@Corin undefined可能与NaN有所不同，但是它仍然不是数字，因此isNaN（undefined）应该是（并且是）true

– Neuhaus
18年1月3日，23：25

#14 楼

我只想分享一个替代方法，它不一定比这里的其他方法好，但我认为值得研究：

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功能，它们可能会很有用。

#15 楼

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

感谢帮助！！

–吉米特·鲁帕尼（Jimit Rupani）
18年5月14日下午6:50

#16 楼

也许也是这样：

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

#17 楼

似乎开箱即用的Node.js不支持isNaN（）。
我使用

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

可以，但是我没有问有关Node.js的问题。

– Paul D. Waite
13年8月24日在13:17

#18 楼

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

相等运算符（==和===）不能用于针对NaN测试值。

请参阅Mozilla文档全局NaN属性是一个表示Not-A-Numbe的值

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

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

#20 楼

根据IEEE 754，除！=以外，所有涉及NaN的关系都评估为false。因此，例如，如果A或B或两者均为NaN，则（A> = B）=假，（A <= B）=假。

#21 楼

我将此答案写在StackOverflow上的另一个问题上，其中另一个检查NaN == null的时间，但是随后将其标记为重复，所以我不想浪费我的工作。
看看Mozilla Developer Network关于NaN。

简短答案
要确保您输入的值是正确的数字或使用distance || 0进行检查，只需使用isNaN()。
长答案
NaN（非数字）是一个当某些数学运算失败时，javascript中的weirdo全局对象经常返回。
您想检查NaN == null是否产生false。使用NaN == NaN甚至可以得到false的结果。
查找变量是否为NaN的简单方法是全局函数isNaN()。
另一个是x !== x，仅当x为NaN时才成立。（感谢提醒@ raphael-schweikert）
但是为什么简短的答案行得通呢？
让我们找出答案。
当您致电NaN == false时，结果为false，与NaN == true相同。
在规范的某个地方，JavaScript的记录始终为假值，其中包括：

NaN-非数字

""-空字符串

false-布尔值false

null-空对象

undefined-未定义变量

0-数值0，包括+0和-0

“确定变量是否为NaN的唯一简单方法是全局函数isNaN（）” –不正确；还有另一种简单的方法：var xIsNaN = x！== x;仅当x为NaN时，才产生true。

–拉斐尔·施维克（Raphael Schweikert）
2015年11月30日6:54

#22 楼

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

#23 楼

找到了另一种方法，只是为了好玩。

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

#24 楼

确切的检查方法是：

//takes care of boolen, undefined and empty

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

#25 楼

我已经创建了这个功能，就像一个超级按钮。
您可以检查数字，而不是检查似乎反直观的NaN。我敢肯定我不是第一个这样做的人，但我想我愿意分享。

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

    return retval;
}

#26 楼

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

您的前提是技术上无穷大不是技术上有缺陷的：math.stackexchange.com/questions/36289/is-infinity-a-number。根据我对答案的理解，无限是数字取决于上下文。

–乔恩·P
17年6月9日在2:36

我将把这个转移到另一个问题

– adddff
17年10月10日在23:26

#27 楼

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

这不优雅。但是在尝试isNAN（）之后，我得出了这个解决方案，这是另一种选择。在此示例中，我还允许使用“。”因为我要掩盖浮标。您也可以反向进行此操作以确保不使用任何数字。

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

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

#28 楼

只需将结果转换为String并与'NaN'比较即可。

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

#29 楼

是（NaN> = 0）吗？......“我不知道”。

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

条件仅在为TRUE时执行。

不在FALSE上。

不在“我不知道”上。

如果您明确寻找NaN值而不是寻找相反的值，那么该功能就不太有用

– liviu blidar
18年1月31日，0：27

#30 楼

所以我看到了一些对此的回应，但我只使用：

function isNaN(x){
     return x == x && typeof x == 'number';
}

它不应该返回x！= x && typeof x ==='number'吗？

– RaymondM
18年1月19日，下午2:55

编程黑洞网