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

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

parseFloat('geoff') == NaN;

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

---

您应该使用全局

isNaN（value）

函数调用，因为：

• 它是跨浏览器支持的
• 有关文档，请参阅

示例：

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

我希望这将对您有所帮助。

请尝试以下代码：

isNaN(parseFloat("geoff"))

isNaN('geoff');

要检查任何值是否为NaN，而不仅仅是数字，请参见此处：

使用以下代码：

isNaN(parseFloat("geoff"))

isNaN('geoff');

看

我使用函数是因为在JavaScript中：

isNaN(undefined) 
-> true

---

至少，要意识到这一点。

NaN是一个特殊值，不能像那样进行测试。我想和大家分享的一件有趣的事情是

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

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

Node.js开箱即用似乎不支持isNaN（） 我和他一起工作

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

---

我在书中遇到了这个技巧，非常简单：

由于NaN是唯一被视为与自身不相等的JavaScript值，因此始终可以通过检查值是否与自身相等来测试值是否为NaN：

---

直到@allsyed发表评论才意识到这一点，但这在ECMA规范中：

虽然@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'

被解析的问题，只需使用

数字（）解析器

与其说是这样，不如说：

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（）
的假值（作为实数布尔值为true）返回为
0
！在这种情况下…parseFloat每次都有效。因此，回到这一点：

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

这似乎涵盖了所有方面。我将其基准测试为比lodash的
\uu.isNaN
慢90%，但那一个并没有涵盖所有的NaN：


要明确的是，我的系统负责人类对“非数字”事物的字面解释，而洛达斯的系统负责计算机对检查事物是否为“NaN”的字面解释。我只想分享另一种选择，它不一定比这里的其他系统更好，但我认为值得一看：

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

函数，则可能会变得有用。

根据IEEE 754，所有涉及NaN的关系计算为false，除了！=。因此，例如，（A>=B）=false和（A 等式运算符（==和===）不能用于根据NaN测试值

看

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

简单的解决方案！ 真的超级简单！这里！有这个方法

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

使用简单到：

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

使用此函数与

另外：请参见下面的第一个示例，了解两个备选实现

---

例子：

函数isreallyan（a）{返回a！==a；}；
变量示例={
"楠":楠,，
“空对象”：{}，
“对NaN的解析”：parseFloat（“$5.32”），
“非空对象”：{a:1，b:2}，
“空数组”：[]，
“半传递分析”：parseInt（'5a5'），
“非空数组”：[“a”、“b”、“c”]，
“Math to NaN”：Math.log（-1），
“未定义的对象”：未定义
}
对于（示例中的x）{
var answer=Isreallyan（示例[x]），
strAnswer=answer.toString（）；
$（“表”）.append（$（“”，{“类”：strAnswer}）.append（$（“”，{“类”）{
html:x
}), $("", {
html:strAnswer
})))
}；

表{边框折叠：折叠；}
th，td{边框：1px实心；填充：2px 5px；}
.true{颜色：红色；}
.false{颜色：绿色；}

---

如果您的环境支持ECMAScript 2015，则您可能希望使用以确保该值确实为

NaN

问题是,比如说,

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

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

Number.isNaN(parseFloat('geoff'))

就要测试类型值是否为

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的一致性，我们也可以使用

请查看更多详细信息。

我写了这个答案来回答另一个问题，即当

NaN==null

时，其他人在哪里检查，但后来它被标记为重复，所以我不想浪费我的工作

查看关于

NaN

---

简短回答 只要使用

distance | | 0

来确保您的值是正确的数字，或者使用

isNaN（）

来检查它

长话短说 NaN（非数字）是javascript中的一个古怪全局对象，在某些数学运算失败时经常返回

您想检查

NaN==null

是否会导致

false

。如果

NaN==NaN

结果为

false

，则检查是否会导致

false

一种确定变量是否为

NaN#2
Number.isNaN(x);

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

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

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

//takes care of boolen, undefined and empty

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

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

    return retval;
}

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

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

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

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

typeof(NaN) // "number"

var myVar = "A";
isNaN(myVar) // true, although "A" is not really of value NaN

var myVar = "A";
isNaN(Number(myVar)) // true. Number(myVar) is NaN here in fact

var myVar; // undefined
myVar !== myVar // false

var myVar = "A";
myVar !== myVar // false

var myVar = NaN
myVar !== myVar // true

function isOfValueNaN(v) {
    return v !== v;
}

var myVar = "A";
isNaN(myVar); // true
isOfValueNaN(myVar); // false

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

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

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

NaN != NaN

isNaN('Hello')      //true
isNaN('2005/12/12') //true
isNaN(undefined)    //true
isNaN('NaN')        //true
isNaN(NaN)          //true
isNaN(0 / 0)        //true

function is_nan(value) {
    return value != value
}

is_nan(parseFloat("geoff"))