为什么 isNaN(" ") （带空格的字符串）等于 false？

Question

在 JavaScript 中，为什么 isNaN(" ") 计算结果为 false，而 isNaN(" x") 计算结果为 true？

我正在对文本输入字段执行数字运算，并检查该字段是否为 null、"" 或 NaN。 当有人在字段中输入少量空格时，我的验证在所有三个空格上都会失败，并且我很困惑为什么它会通过 isNaN 检查。

Answer 1

JavaScript 将空字符串解释为 0，从而导致 isNAN 测试失败。 您可以先对字符串使用 parseInt，这不会将空字符串转换为 0。结果应该会失败 isNAN。

Answer 2

您可能会感到惊讶，也可能不会，但这里有一些测试代码，可以向您展示 JavaScript 引擎的古怪之处。

document.write(isNaN("")) // false
document.write(isNaN(" "))  // false
document.write(isNaN(0))  // false
document.write(isNaN(null)) // false
document.write(isNaN(false))  // false
document.write("" == false)  // true
document.write("" == 0)  // true
document.write(" " == 0)  // true
document.write(" " == false)  // true
document.write(0 == false) // true
document.write(" " == "") // false

所以这意味着

" " == 0 == false

玩得

"" == 0 == false

，但是

"" != " "

开心:)

Answer 3

为了更好地理解它，请打开 Ecma-Script 规范 pdf第 43 页“ToNumber 应用于字符串类型”

如果字符串具有数字语法，可以包含任意数量的空白字符，则可以将其转换为 Number 类型。 空字符串的计算结果为 0。字符串 'Infinity' 也应该给出

isNaN('Infinity'); // false

Answer 4

尝试使用：

alert(isNaN(parseInt("   ")));

或者

alert(isNaN(parseFloat("    ")));

Answer 5

来自 MDN 原因对于您面临的问题

当 isNaN 函数的参数不是 Number 类型时，该值首先被强制转换为 Number。 然后测试结果值以确定它是否为 NaN。

您可能需要检查以下综合答案，其中还涵盖了 NaN 相等性比较。

如何测试 JavaScript 变量是否为 NaN

Answer 6

我认为这是因为 Javascript 的输入：' ' 被转换为零，而 'x' 则不是：

alert(' ' * 1); // 0
alert('x' * 1); // NaN

Answer 7

不完全正确的答案

Antonio Haley 的高度赞成并接受的答案在这里做出了一个错误的假设，即这个过程通过 JavaScript 的 <代码>parseInt函数：

您可以在字符串上使用 parseInt ...结果应该失败 isNAN。

我们可以很容易地用字符串 "123abc" 反驳这个说法：

parseInt("123abc")    // 123     (a number...
isNaN("123abc")       // true     ...which is not a number)

通过这个，我们可以看到 JavaScript 的 parseInt 函数返回 "123abc" 作为数字 123，但其 isNaN 函数告诉我们 "123abc" 不是 一个数字。

正确答案

ECMAScript-262 定义了 isNaN 检查在 第 18.2.3 节。

18.2.3 isNaN（数字）

isNaN 函数是 %isNaN% 内部对象。 当使用一个参数编号调用 isNaN 函数时，将执行以下步骤：

1. 令 num 为？ ToNumber（数字）。
2. 如果 num 为 NaN，则返回 true。
3. 否则，返回false。

它引用的 ToNumber 函数也在 ECMAScript-262 的第 7.1 节中定义.3。 在这里，我们了解 JavaScript 如何处理传入此函数的字符串。

问题中给出的第一个示例是一个仅包含空格字符的字符串。 本节规定：

空或仅包含空格的 StringNumericLiteral 将转换为 +0。

因此，" " 示例字符串被转换为 +0，这是一个数字。

同一节还指出：

如果语法无法将 String 解释为 StringNumericLiteral 的扩展，则 ToNumber 的结果为 NaN >.

如果不引用该部分中包含的所有检查，问题中给出的 " x" 示例就会属于上述情况，因为它不能解释为 StringNumericLiteral。 因此，" x" 被转换为 NaN。

Answer 8

函数 isNaN("") 执行字符串到数字类型的强制转换

ECMAScript 3-5 为 typeof 运算符定义了以下返回值：

• 未定义
• 对象（null、对象、数组）
• 布尔
• 值
• 字符串
• 函数

最好将我们的测试包装在函数体中：

function isNumber (s) {
    return typeof s == 'number'? true
           : typeof s == 'string'? (s.trim() === ''? false : !isNaN(s))
           : (typeof s).match(/object|function/)? false
           : !isNaN(s)
}

此函数并非旨在测试变量类型，而是测试强制值。 您可能希望将此函数调用为 isNumberCoerced()

例如，布尔值和字符串被强制转换为数字，因此如果不需要测试除 类型 以外的类型， >字符串和数字，那么以下代码片段可以用作某些条件的一部分：

if (!isNaN(s) && s.toString().trim()!='') // 's' can be boolean, number or string
    alert("s is a number")

Answer 9

如果您想实现精确的 isNumber 函数，可以使用 Douglas Crockford 的 Javascript：The Good Parts [第 105 页] 中的一种方法。

var isNumber = function isNumber(value) {
   return typeof value === 'number' && 
   isFinite(value);
}

Answer 10

NaN !== "not a number"

NaN 是 Number 类型的值，

这是 ECMAScript 中 isNaN() 的定义

1. Let num be ToNumber(number).
2. ReturnIfAbrupt(num).
3. If num is NaN, return true.
4. Otherwise, return false.

尝试将任何值转换为 Number。

Number(" ") // 0
Number("x") // NaN
Number(null) // 0

如果你想判断该值是否为NaN，你应该先尝试将其转换为Number值。

Answer 11

如果您确实想要正确检查它是否是整数，我建议您使用以下函数：

function isInteger(s)
{
   return Math.ceil(s) == Math.floor(s);
}

Answer 12

isNaN(" ") 为 false 是 isNaN 全局函数令人困惑的行为的一部分，因为它将非数字强制转换为数字类型。

来自 MDN ：

自从 isNaN 函数规范的最早版本以来，它对非数字参数的行为一直令人困惑。 当 isNaN 函数的参数不是 Number 类型时，该值首先被强制转换为 Number。 然后测试结果值以确定它是否为 NaN。 因此，对于非数字，当强制转换为数字类型时会产生有效的非 NaN 数值（特别是空字符串和布尔基元，当强制转换时给出数值零或一），“假”返回值可能是意外的； 例如，空字符串肯定是“不是数字”。

另请注意，在 ECMAScript 6 中，现在还提供了 Number.isNaN 方法，根据 MDN：

与全局 isNaN() 函数相比，Number.isNaN() 不会遇到将参数强制转换为数字的问题。 这意味着现在可以安全地传递通常会转换为 NaN 的值，但实际上与 NaN 的值不同。 这也意味着只有数字类型的值（也是 NaN）才会返回 true。

不幸的是：

即使是 ECMAScript 6 Number.isNaN 方法也有其自身的问题，如博客文章中所述 - 修复丑陋的 JavaScript 和 ES6 NaN 问题。

Answer 13

isNaN 函数需要一个 Number 作为其参数，因此任何其他类型的参数（在您的情况下为字符串）将在执行实际函数逻辑之前转换为 Number。 （请注意 NaN 也是 Number 类型的值！）

顺便说一句。 这对于所有内置函数来说很常见 - 如果它们需要某种类型的参数，则实际参数将使用标准转换函数进行转换。 所有基本类型（bool、string、number、object、date、null、undefined）之间都有标准转换。

String 到 Number 的标准转换可以显式调用与Number()。 所以我们可以看到：

• Number(" ") 计算结果为 0
• Number(" x") 计算结果为 NaN >

鉴于此，isNaN 函数的结果是完全符合逻辑的！

真正的问题是为什么标准字符串到数字的转换会像这样工作。 字符串到数字的转换实际上旨在将“123”或“17.5e4”等数字字符串转换为等效的数字。 转换首先跳过初始空格（因此“123”有效），然后尝试将其余部分解析为数字。 如果它不可解析为数字（“x”则不可解析），则结果为 NaN。 但是有一个明确的特殊规则，即空字符串或只有空格的字符串将转换为 0。因此这解释了转换。

参考：http://www.ecma-international.org/ ecma-262/5.1/#sec-9.3.1

Answer 14

我不确定为什么，但为了解决这个问题，您可以在检查之前删除空格。 无论如何你可能都想这样做。

Answer 15

我编写了这个快速的小函数来帮助解决这个问题。

function isNumber(val) {
     return (val != undefined && val != null && val.toString().length > 0 && val.toString().match(/[^0-9\.\-]/g) == null);
};

它只是检查非数字 (0-9)、非“-”或“.”以及非未定义、null 或空的任何字符，如果没有匹配则返回 true。 :)

Answer 16

正如其他人所解释的，isNaN 函数会在验证空字符串之前将其强制转换为数字，从而将空字符串更改为 0（这是一个有效的数字）。
但是，我发现当尝试解析空字符串或仅包含空格的字符串时，parseInt 函数将返回 NaN。 因此，以下组合似乎运行良好：

if ( isNaN(string) || isNaN(parseInt(string)) ) console.log('Not a number!');

此检查将起作用对于正数、负数和带小数点的数字，所以我相信它涵盖了所有常见的数字情况。

Answer 17

我用这个

    function isNotANumeric(val) {
    	if(val.trim && val.trim() == "") {
         return true;
      } else {
      	 return isNaN(parseFloat(val * 1));
      }
    }
    
    alert(isNotANumeric("100"));  // false
    alert(isNotANumeric("1a"));   // true
    alert(isNotANumeric(""));     // true
    alert(isNotANumeric("   "));  // true

Answer 18

这个功能在我的测试中似乎有效

function isNumber(s) {
    if (s === "" || s === null) {
        return false;
    } else {
        var number = parseInt(s);
        if (number == 'NaN') {
            return false;
        } else {
            return true;
        }
    }
}

Answer 19

关于什么

function isNumberRegex(value) {        
    var pattern = /^[-+]?\d*\.?\d*$/i;
    var match = value.match(pattern);
    return value.length > 0 && match != null;
}

Answer 20

JavaScript 内置 isNaN 函数 - 正如默认情况下所预期的 - 一个“动态类型运算符”。
因此，（在 DTC 过程中）可能产生简单 true | 的所有值。 false 例如 ""、" "、" 000"，不能为 NaN。

这意味着提供的参数将首先进行转换，如下所示：

function isNaNDemo(arg){
   var x = new Number(arg).valueOf();
   return x != x;
}

解释：

在函数体的顶行中，我们（首先）尝试成功地将参数转换为数字对象。 （第二），为了方便起见，我们使用点运算符立即剥离所创建对象的原始值。

在第二行中，我们采用上一步中获得的值，并且利用 NaN 不等于宇宙中任何东西的事实，甚至不等于本身，例如： NaN == NaN >>> false 最终将其与自身进行比较（是否不平等）。

这样，仅当且仅当提供的参数返回尝试转换为数字对象失败时，函数返回才会产生 true，即，不是-a-number； 例如，NaN。

---

isNaNstatic( )

但是，对于静态类型运算符 - 如果需要并且在需要时 - 我们可以编写一个简单得多的函数，例如：

function isNaNstatic(x){   
   return x != x;
}

并完全避免 DTC，这样如果参数不是明确的 NaN 数，它将返回 false。 因此，针对以下内容进行测试：

isNaNStatic(" x"); // 将返回 false 因为它仍然是一个字符串。

然而：
isNaNStatic(1/"x"); // 当然会返回 true。 例如 isNaNStatic(NaN); >>> 正确。

但与 isNaN 相反，isNaNStatic("NaN"); >>> false 因为它（参数）是一个普通字符串。

附：
isNaN 的静态版本在现代编码场景中非常有用。 这很可能是我花时间发布此内容的主要原因之一。

问候。

Answer 21

isNAN() 是一个判断给定参数是否为非法数字的函数。
isNaN 将参数类型转换为 Number 类型。 如果你想检查参数是否是数字？ 请使用 jQuery 中的 $.isNumeric() 函数。

即 isNaN(foo) 等价于 isNaN(Number(foo))
出于显而易见的原因，它接受所有数字都为数字的任何字符串。 对于前。

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

Answer 22

当检查带有空格或 " " 的某个字符串值是否为 isNaN 时，可能会尝试执行字符串验证，例如：

// value = "123 "
if (value.match(/\s/) || isNaN(value)) {
// 做一点事
}

Answer 23

我发现拥有一个特定于 Number 类的方法（因为其他执行转换（如 parseInt）的函数对于其中一些值有不同的输出）并使用原型继承是很方便的。

Object.assign(Number.prototype, {
  isNumericallyValid(num) {
    if (
      num === null
      || typeof num === 'boolean'
      || num === ''
      || Number.isNaN(Number(num))
    ) {
      return false;
    }
    return true;
  }
});

Answer 24

我使用以下内容。

x=(isNaN(parseFloat(x)))？ 0.00：parseFloat(x)；

Answer 25

let isNotNumber = val => isNaN(val) || (val.trim && val.trim() === '');

console.log(isNotNumber(' '));
console.log(isNotNumber('1'));
console.log(isNotNumber('123x'));
console.log(isNotNumber('x123'));
console.log(isNotNumber('0'));
console.log(isNotNumber(3));
console.log(isNotNumber('    x'));
console.log(isNotNumber('1.23'));
console.log(isNotNumber('1.23.1.3'));

if(!isNotNumber(3)){
  console.log('This is a number');
}