NaN 是唯一不等于自身的值：

> NaN === NaN
false

Array.prototype.indexOf 也使用严格相等（===）。因此，您无法通过该方法在数组中搜索 NaN

> [ NaN ].indexOf(NaN)
-1

如果要检查值是否为 NaN，则必须使用全局函数 isNaN()：

> isNaN(NaN)
true
> isNaN(33)
false

但是，isNaN 对非数字不起作用，因为它首先将这些值转换为数字。该转换可能会产生 NaN，然后函数会错误地返回 true

> isNaN('xyz')
true

因此，最好将 isNaN 与类型检查结合使用：

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

或者，您可以检查该值是否不等于自身（因为 NaN 是唯一具有此特征的值）。但这不太容易理解：

function myIsNaN(value) {
    return value !== value;
}

请注意，此行为由 IEEE 754 规定。如第 7.11 节“比较谓词的详细信息”中所述：^[15]

数字的幅度可以达到多大取决于其内部表示形式（如 数字的内部表示形式中所述），它是以下各项的算术乘积

指数必须介于（不包括）−1023 和 1024 之间。如果指数太小，则该数字变为 0。如果指数太大，则变为 Infinity。2¹⁰²³ 仍然可以表示，但 2¹⁰²⁴ 不能

> Math.pow(2, 1023)
8.98846567431158e+307
> Math.pow(2, 1024)
Infinity

除以零会产生 Infinity 作为错误值：

> 3 / 0
Infinity
> 3 / -0
-Infinity

如果您尝试用另一个 Infinity“抵消”一个 Infinity，则会得到错误结果 NaN：

> Infinity - Infinity
NaN
> Infinity / Infinity
NaN

如果您尝试超出 Infinity，您仍然会得到 Infinity

> Infinity + Infinity
Infinity
> Infinity * Infinity
Infinity

严格相等和宽松相等对 Infinity 有效：

> var x = Infinity;
> x === Infinity
true

此外，全局函数 isFinite() 允许您检查值是否为实际数字（既不是无限大也不是 NaN）：

> isFinite(5)
true
> isFinite(Infinity)
false
> isFinite(NaN)
false

JavaScript 想方设法隐藏了有两个零的事实。鉴于它们通常没有区别，因此建议您配合单一零的错觉。让我们看看这种错觉是如何维持的。

在 JavaScript 中，您通常编写 0，这意味着 +0。但是 -0 也显示为 0。这是您在使用浏览器命令行或 Node.js REPL 时看到的内容

> -0
0

这是因为标准的 toString() 方法将两个零都转换为相同的 '0'：

> (-0).toString()
'0'
> (+0).toString()
'0'

相等性也不区分零。即使是 === 也不行：

> +0 === -0
true

Array.prototype.indexOf 使用 === 来搜索元素，从而保持了这种错觉

> [ -0, +0 ].indexOf(+0)
0
> [ +0, -0 ].indexOf(-0)
0

排序运算符也认为零是相等的

> -0 < +0
false
> +0 < -0
false

您如何实际观察到两个零是不同的？您可以除以零（-Infinity 和 +Infinity 可以 通过 === 区分）：

> 3 / -0
-Infinity
> 3 / +0
Infinity

另一种执行除以零的方法是通过 Math.pow()（请参阅 数值函数）

> Math.pow(-0, -1)
-Infinity
> Math.pow(+0, -1)
Infinity

Math.atan2()（请参阅 三角函数）也表明这两个零是不同的：

> Math.atan2(-0, -1)
-3.141592653589793
> Math.atan2(+0, -1)
3.141592653589793

区分这两个零的规范方法是除以零。因此，用于检测负零的函数看起来如下所示：

function isNegativeZero(x) {
    return x === 0 && (1/x < 0);
}

以下是该函数的使用方法

> isNegativeZero(0)
false
> isNegativeZero(-0)
true
> isNegativeZero(33)
false

如果您使用最大为 53 位的整数，则没有问题。 不幸的是，您在编程中经常会遇到 64 位无符号整数（Twitter ID、数据库等）。这些必须存储在 JavaScript 的字符串中。如果要对这些整数执行算术运算，则需要特殊的库。有计划将更大的整数引入 JavaScript，但这需要一段时间。

ECMAScript 6 将 提供以下常量：

Number.MAX_SAFE_INTEGER = Math.pow(2, 53)-1;
Number.MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;

它还将提供一个函数来确定 整数是否安全：

Number.isSafeInteger = function (n) {
    return (typeof n === 'number' &&
        Math.round(n) === n &&
        Number.MIN_SAFE_INTEGER <= n &&
        n <= Number.MAX_SAFE_INTEGER);
}

对于给定值 n，此函数首先检查 n 是否为数字和整数。如果两项检查均成功，则如果 n 大于或等于 MIN_SAFE_INTEGER 且小于或等于 MAX_SAFE_INTEGER，则 n 是安全的。

我们如何确保算术 计算的结果是正确的？例如，以下结果显然是不正确的：

> 9007199254740990 + 3
9007199254740992

我们有两个安全的操作数，但结果不安全

> Number.isSafeInteger(9007199254740990)
true
> Number.isSafeInteger(3)
true
> Number.isSafeInteger(9007199254740992)
false

以下结果也不正确

> 9007199254740995 - 10
9007199254740986

这次，结果是安全的，但其中一个操作数不是

> Number.isSafeInteger(9007199254740995)
false
> Number.isSafeInteger(10)
true
> Number.isSafeInteger(9007199254740986)
true

因此，仅当所有操作数和结果均安全时，应用整数运算符 op 的结果才能保证是正确的。更正式地说

isSafeInteger(a) && isSafeInteger(b) && isSafeInteger(a op b)

意味着 a op b 是正确的结果。

如果掩码（第二个操作数）为 0，则不会更改任何位，并且结果是第一个操作数，强制转换为有符号 32 位整数。 这是执行此类强制转换的规范方法，例如，asm.js 使用了此方法（请参阅 JavaScript 是否足够快？）

// Convert x to a signed 32-bit integer
function ToInt32(x) {
    return x | 0;
}

ToInt32() 移除 小数部分并应用模 2³²：

> ToInt32(1.001)
1
> ToInt32(1.999)
1
> ToInt32(1)
1
> ToInt32(-1)
-1
> ToInt32(Math.pow(2, 32)+1)
1
> ToInt32(Math.pow(2, 32)-1)
-1

适用于按位或的技巧也适用于移位运算符：如果移位 0 位，则移位操作的结果是第一个操作数，强制转换为 32 位整数。 以下是一些通过移位运算符实现 ECMAScript 规范操作的示例：

// Convert x to a signed 32-bit integer
function ToInt32(x) {
    return x << 0;
}

// Convert x to a signed 32-bit integer
function ToInt32(x) {
    return x >> 0;
}

// Convert x to an unsigned 32-bit integer
function ToUint32(x) {
    return x >>> 0;
}

以下是 ToUint32() 在 实际应用中的示例：

> ToUint32(-1)
4294967295
> ToUint32(Math.pow(2, 32)-1)
4294967295
> ToUint32(Math.pow(2, 32))
0

您必须自行决定效率的略微提高 是否值得以代码更难理解为代价。另请注意，位运算符人为地将自己限制为 32 位，这通常既不必要也不有用。使用 Math 函数之一（可能还需要 Math.abs()）是一种更易于理解且可以说是更好的选择。

基数的范围为 2 ≤ radix ≤ 36。它决定了要解析的数字的基数。如果基数大于 10，则除了 0-9 之外，还会使用字母作为数字（不区分大小写）。

如果缺少 radix，则假定为 10，除非 str 以“0x”或“0X”开头，在这种情况下，radix 设置为 16（十六进制）

> parseInt('0xA')
10

如果 radix 已经是 16，则十六进制前缀是可选的

> parseInt('0xA', 16)
10
> parseInt('A', 16)
10

到目前为止，我已经根据 ECMAScript 规范描述了 parseInt() 的行为。此外，如果 str 以零开头，则某些引擎会将基数设置为 8

> parseInt('010')
8
> parseInt('0109')  // ignores digits ≥ 8
8

因此，最好始终显式声明基数，始终使用两个参数调用 parseInt()。

以下是一些示例

> parseInt('')
NaN
> parseInt('zz', 36)
1295
> parseInt('   81', 10)
81

> parseInt('12**', 10)
12
> parseInt('12.34', 10)
12
> parseInt(12.34, 10)
12

不要使用 parseInt() 将数字转换为整数。最后一个示例让我们看到了可以使用 parseInt() 将数字转换为整数的希望。 唉，以下是一个转换不正确的示例：

> parseInt(1000000000000000000000.5, 10)
1

参数首先转换为字符串

> String(1000000000000000000000.5)
'1e+21'

parseInt 不认为“e”是整数数字，因此在 1 之后停止解析。以下是另一个示例

> parseInt(0.0000008, 10)
8
> String(0.0000008)
'8e-7'

不应使用 parseInt() 将数字转换为整数：强制转换为字符串是不必要的迂回操作，即使这样，结果也不总是正确的。

parseInt() 适用于 解析字符串，但您必须注意，它会在遇到第一个非法数字时停止。通过 Number() 解析字符串（请参阅 函数 Number）不太宽容，但可能会产生非整数。

计算二进制数的二进制补码（或反码）的两种常见方法是

32 位整数没有显式符号，但您仍然可以对负数进行编码。 例如，−1 可以编码为 1 的补码：将 1 与结果相加得到 0（在 32 位内）。正数和负数之间的界限是模糊的；4294967295 (2³²−1) 和 −1 在这里是相同的整数。但是，当您将此类整数与 JavaScript 数字（具有显式符号而不是隐式符号）进行相互转换时，必须确定符号。因此，有符号 32 位整数 分为两组：

最高位通常称为 符号位。因此，当转换为 JavaScript 数字时，解释为有符号 32 位整数的 4294967295 变为 −1

> ToInt32(4294967295)
-1

ToInt32() 在 通过位运算符获取 32 位整数 中进行了说明。

在以下示例中，我们通过以下两个操作使用二进制数：

对于进制 10，toString() 在两种情况下使用指数表示法（小数点前一位数字）。首先，如果一个数字的小数点前有超过 21 位数字

> 1234567890123456789012
1.2345678901234568e+21
> 123456789012345678901
123456789012345680000

其次，如果一个数字以 0. 开头，后跟五个以上的零和一个非零数字

> 0.0000003
3e-7
> 0.000003
0.000003

在所有其他情况下，都使用定点表示法。