JavaScript 中的 Infinity 与 NaN：它们的算术行为与规范定义
在 JavaScript 的数值体系中，除了常见的有限数字（整数和浮点数），还存在着两种特殊的数值：Infinity（无穷大）和 NaN（非数字）。它们是 ECMAScript 规范定义的一部分，并且遵循 IEEE 754 双精度浮点数标准，对 JavaScript 应用程序的健壮性和正确性有着深远的影响。理解它们的产生机制、算术行为、比较特性以及如何正确地检测和处理它们，是每位 JavaScript 开发者必备的知识。
第一章：JavaScript 数值类型的基础与 IEEE 754 标准
JavaScript 只有一种数字类型，即 Number。这种类型是基于 IEEE 754 标准的双精度 64 位浮点数表示。这意味着所有数字，包括整数，都是以浮点数的形式存储的。这种设计带来了极大的灵活性，但也引入了浮点数固有的特性，例如精度问题，以及对特殊值 Infinity 和 NaN 的支持。
IEEE 754 标准不仅定义了如何表示有限的浮点数，还定义了如何表示一些特殊的“非数字”值。这些特殊值对于处理溢出、下溢和无效操作至关重要。
- 有限数：包括正数、负数和零。
- 无穷大 (Infinity)：表示数值超出了可表示范围的正无穷或负无穷。
- 非数字 (NaN)：表示一个非法的或未定义的数学运算结果。
- 符号零 (+0 和 -0)：尽管在大多数情况下
+0和-0行为相同，但在某些特定操作（如除法）中它们具有不同的含义。
理解这些基础是深入探讨 Infinity 和 NaN 的前提。
第二章：无垠之境 —— Infinity
Infinity 代表数学上的无穷大。在 JavaScript 中，它是一个特殊的数值，表示任何超出双精度浮点数表示范围的数字。
2.1 Infinity 的定义与表示
在 JavaScript 中，Infinity 可以通过多种方式访问：
- 全局属性
Infinity：这是一个全局可访问的属性，其值是正无穷大。 Number.POSITIVE_INFINITY：与全局Infinity相同，表示正无穷大。Number.NEGATIVE_INFINITY：表示负无穷大。
这些值都是 Number 类型。
console.log(Infinity); // Infinity
console.log(Number.POSITIVE_INFINITY); // Infinity
console.log(Number.NEGATIVE_INFINITY); // -Infinity
console.log(typeof Infinity); // "number"
console.log(typeof Number.POSITIVE_INFINITY); // "number"
console.log(typeof Number.NEGATIVE_INFINITY); // "number"2.2 Infinity 的产生场景
Infinity 主要在以下几种情况下产生：
-
数值溢出 (Overflow)：当一个计算结果超出了 JavaScript 能够表示的最大正数 (
Number.MAX_VALUE) 或最小负数 (Number.MIN_VALUE的负数形式) 时，就会得到Infinity或-Infinity。
Number.MAX_VALUE大约是 1.7976931348623157e+308。
Number.MIN_VALUE是最接近零的正数，大约是 5e-324。console.log(Number.MAX_VALUE); // 1.7976931348623157e+308 console.log(Number.MAX_VALUE * 2); // Infinity console.log(Number.MAX_VALUE + Number.MAX_VALUE); // Infinity console.log(-Number.MAX_VALUE * 2); // -Infinity -
除以零 (Division by Zero)：在大多数编程语言中，除以零会抛出错误。但在 JavaScript (遵循 IEEE 754) 中，一个有限的非零数除以零会得到
Infinity或-Infinity，这取决于被除数的符号。- 正数除以
+0得到Infinity。 - 负数除以
+0得到-Infinity。 - 正数除以
-0得到-Infinity。 - 负数除以
-0得到Infinity。
console.log(1 / 0); // Infinity console.log(-1 / 0); // -Infinity console.log(1 / -0); // -Infinity console.log(-1 / -0); // Infinity值得注意的是，
0 / 0不会得到Infinity，而是NaN，因为它是未定义的。 - 正数除以
-
某些数学函数的结果：一些数学函数在特定输入下会返回
Infinity。console.log(Math.pow(2, 1024)); // Infinity (2的1024次方超出表示范围) console.log(Math.exp(710)); // Infinity (e的710次方超出表示范围) console.log(Math.log(0)); // -Infinity (自然对数在0处趋近于负无穷) -
parseFloat()/Number()处理特定字符串：当parseFloat()或Number()函数解析字符串"Infinity"或"-Infinity"时，会返回相应的Infinity值。console.log(parseFloat("Infinity")); // Infinity console.log(parseFloat("-Infinity")); // -Infinity console.log(Number("Infinity")); // Infinity console.log(Number("-Infinity")); // -Infinity
2.3 Infinity 的算术行为
Infinity 在算术运算中表现出特定的传染性，但并非所有运算都如此。
2.3.1 与有限数的运算
-
加法 (
+) 和减法 (-)：Infinity加上或减去任何有限数（包括NaN和Infinity本身除外）仍然是Infinity。console.log(Infinity + 100); // Infinity console.log(Infinity - 50); // Infinity console.log(-Infinity + 20); // -Infinity console.log(-Infinity - 30); // -Infinity -
*乘法 (``)**：
Infinity乘以一个正数得到Infinity。Infinity乘以一个负数得到-Infinity。Infinity乘以0得到NaN（未定义）。
console.log(Infinity * 5); // Infinity console.log(Infinity * -5); // -Infinity console.log(-Infinity * 5); // -Infinity console.log(-Infinity * -5); // Infinity console.log(Infinity * 0); // NaN console.log(-Infinity * 0); // NaN -
除法 (
/)：Infinity除以任何有限非零数，结果是Infinity或-Infinity，取决于符号。- 任何有限非零数除以
Infinity，结果是0（或-0）。 Infinity除以0得到Infinity或-Infinity。
console.log(Infinity / 2); // Infinity console.log(Infinity / -2); // -Infinity console.log(10 / Infinity); // 0 console.log(-10 / Infinity); // -0 console.log(10 / -Infinity); // -0 console.log(-10 / -Infinity); // 0 console.log(Infinity / 0); // Infinity console.log(-Infinity / 0); // -Infinity -
取模 (
%)：Infinity对任何数取模，或任何数对Infinity取模，结果都是NaN。console.log(Infinity % 10); // NaN console.log(10 % Infinity); // NaN console.log(Infinity % Infinity); // NaN (稍后详细说明) -
幂运算 (
Math.pow())：console.log(Math.pow(Infinity, 2)); // Infinity console.log(Math.pow(Infinity, -1)); // 0 console.log(Math.pow(-Infinity, 3)); // -Infinity console.log(Math.pow(-Infinity, 2)); // Infinity console.log(Math.pow(1, Infinity)); // NaN (1的任意次方是1，但这里是无穷，所以是未定义) console.log(Math.pow(0, Infinity)); // 0 console.log(Math.pow(Infinity, 0)); // 1 (任何数的0次方是1，包括Infinity)
2.3.2 与 Infinity 的运算
Infinity + Infinity得到Infinity。Infinity - Infinity得到NaN（未定义）。Infinity * Infinity得到Infinity。Infinity / Infinity得到NaN（未定义）。-
Infinity % Infinity得到NaN（未定义）。console.log(Infinity + Infinity); // Infinity console.log(Infinity - Infinity); // NaN console.log(Infinity * Infinity); // Infinity console.log(Infinity / Infinity); // NaN console.log(Infinity % Infinity); // NaN
2.3.3 与 NaN 的运算
任何包含 NaN 的算术运算，其结果通常都是 NaN。Infinity 也不例外。
console.log(Infinity + NaN); // NaN
console.log(Infinity * NaN); // NaN
console.log(Infinity / NaN); // NaN2.4 Infinity 的比较行为
Infinity 在比较运算中表现为真正的无穷大。
Infinity大于任何有限数和-Infinity。-Infinity小于任何有限数和Infinity。Infinity等于Infinity。-Infinity等于-Infinity。
console.log(Infinity > 1000000000); // true
console.log(Infinity < 1000000000); // false
console.log(Infinity === Infinity); // true
console.log(Infinity === -Infinity); // false
console.log(-Infinity < 0); // true
console.log(-Infinity === -Infinity); // true需要注意的是，Infinity 不与 NaN 进行有意义的比较。与 NaN 的任何比较（除了 !==）都将返回 false。
console.log(Infinity > NaN); // false
console.log(Infinity < NaN); // false
console.log(Infinity === NaN); // false
console.log(Infinity !== NaN); // true2.5 Infinity 的类型转换
-
String()转换：Infinity转换为字符串"Infinity"，-Infinity转换为"-Infinity"。console.log(String(Infinity)); // "Infinity" console.log(String(-Infinity)); // "-Infinity" -
Boolean()转换：Infinity和-Infinity都被视为真值 (true)。console.log(Boolean(Infinity)); // true console.log(Boolean(-Infinity)); // true -
Number()转换：Number(Infinity)仍然是Infinity。console.log(Number(Infinity)); // Infinity -
parseInt()/parseFloat()转换：parseInt()会尝试解析直到遇到非数字字符，所以parseInt("Infinity")会返回NaN。而parseFloat()能够识别"Infinity"并将其转换为Infinity。console.log(parseInt("Infinity")); // NaN console.log(parseFloat("Infinity")); // Infinity
2.6 判断 Infinity 的方法
-
直接比较 (
===)：最直接的方法是使用严格相等运算符与Infinity或-Infinity进行比较。let result = 1 / 0; if (result === Infinity) { console.log("结果是正无穷大。"); } let anotherResult = -Math.log(0); if (anotherResult === Infinity) { // -(-Infinity) = Infinity console.log("另一个结果也是正无穷大。"); } -
Number.isFinite()：这是一个静态方法，用于检查一个值是否为有限数。它不会进行类型转换，只有当值是真正的有限数字时才返回true。console.log(Number.isFinite(123)); // true console.log(Number.isFinite(Infinity)); // false console.log(Number.isFinite(-Infinity)); // false console.log(Number.isFinite(NaN)); // false console.log(Number.isFinite("123")); // false (因为它不是数字类型) -
全局函数
isFinite()：这个全局函数会首先将参数尝试转换为数字。如果转换后的值是有限数（非Infinity，非NaN），则返回true。console.log(isFinite(123)); // true console.log(isFinite(Infinity)); // false console.log(isFinite(-Infinity)); // false console.log(isFinite(NaN)); // false console.log(isFinite("123")); // true (因为它被转换为数字 123) console.log(isFinite("Infinity")); // false (因为它被转换为 Infinity) console.log(isFinite(null)); // true (null 被转换为 0) console.log(isFinite(true)); // true (true 被转换为 1)由于
isFinite()会进行类型转换，所以在某些情况下可能会产生意想不到的结果，因此通常更推荐使用Number.isFinite()进行严格的有限数检查。
Infinity 行为总结表
| 运算类型 | 表达式示例 | 结果 | 备注 |
|---|---|---|---|
| 加法 | Infinity + 5 |
Infinity |
无穷大加有限数仍是无穷大 |
Infinity + Infinity |
Infinity |
||
Infinity + (-Infinity) |
NaN |
不确定形式 | |
| 减法 | Infinity - 5 |
Infinity |
无穷大减有限数仍是无穷大 |
Infinity - Infinity |
NaN |
不确定形式 | |
| 乘法 | Infinity * 5 |
Infinity |
无穷大乘正数仍是无穷大 |
Infinity * -5 |
-Infinity |
无穷大乘负数符号反转 | |
Infinity * 0 |
NaN |
不确定形式 | |
Infinity * Infinity |
Infinity |
||
| 除法 | Infinity / 5 |
Infinity |
无穷大除以有限非零数 |
Infinity / -5 |
-Infinity |
||
5 / Infinity |
0 |
有限数除以无穷大趋近于零 | |
Infinity / Infinity |
NaN |
不确定形式 | |
| 取模 | Infinity % 5 |
NaN |
无穷大取模无意义 |
5 % Infinity |
NaN |
有限数对无穷大取模也无意义 | |
| 幂运算 | Math.pow(Infinity, 2) |
Infinity |
|
Math.pow(Infinity, 0) |
1 |
任何数的0次方是1 | |
Math.pow(1, Infinity) |
NaN |
1的无穷大次幂是不确定形式 | |
| 比较 | Infinity > 100 |
true |
|
Infinity === Infinity |
true |
||
Infinity === -Infinity |
false |
||
Infinity === NaN |
false |
NaN 与任何值都不相等，包括自身和无穷大 |
|
Infinity !== NaN |
true |
第三章：非数之谜 —— NaN
NaN（Not-a-Number）是一个特殊的数值，它表示一个非法的或未定义的数学运算结果。与 Infinity 不同，NaN 具有一些非常独特的行为，尤其是它不等于自身。
3.1 NaN 的定义与表示
NaN 可以通过全局属性 NaN 或 Number.NaN 访问。它们的值是相同的。
console.log(NaN); // NaN
console.log(Number.NaN); // NaN
console.log(typeof NaN); // "number"虽然 NaN 字面上是非数字，但它的 typeof 结果却是 "number"，这是因为它是 JavaScript 数值类型中的一个特殊成员，遵循 IEEE 754 标准。
3.2 NaN 的产生场景
NaN 主要在以下几种情况下产生：
-
无效的数学运算：当数学运算的结果是未定义或无法表示的真实数字时。
console.log(0 / 0); // NaN console.log(Infinity - Infinity); // NaN console.log(Infinity * 0); // NaN console.log(Infinity / Infinity); // NaN console.log(Math.sqrt(-1)); // NaN (负数的平方根在实数域无解) console.log(Math.log(-1)); // NaN (负数的对数在实数域无解) -
字符串解析失败：当尝试将一个无法解析为数字的字符串转换为数字时。
console.log(parseInt("hello")); // NaN console.log(parseFloat("world")); // NaN console.log(Number("abc")); // NaN console.log(Number("123a")); // NaN (Number() 严格，不能有非数字字符)注意
parseInt("123a")会返回123，因为它会解析到第一个非数字字符为止。 -
尝试将非数字值转换为数字进行数学运算：当一个操作数预期是数字，但提供了一个无法转换为有效数字的值时。
let obj = {}; console.log(obj * 2); // NaN (obj 无法转换为数字) console.log(undefined + 1); // NaN (undefined 转换为 NaN)
3.3 NaN 的算术行为
NaN 在算术运算中具有极强的传染性。任何涉及 NaN 的算术运算，其结果通常都是 NaN。这被称为 NaN 的“传播”特性。
-
与有限数的运算：
console.log(NaN + 10); // NaN console.log(NaN - 5); // NaN console.log(NaN * 2); // NaN console.log(NaN / 3); // NaN console.log(NaN % 4); // NaN -
与
Infinity的运算：console.log(NaN + Infinity); // NaN console.log(NaN * Infinity); // NaN console.log(NaN / Infinity); // NaN -
与
NaN的运算：console.log(NaN + NaN); // NaN console.log(NaN * NaN); // NaN
3.4 NaN 的比较行为
这是 NaN 最独特且最重要的特性：NaN 不等于它自身。 无论使用 == (宽松相等) 还是 === (严格相等)，NaN 与 NaN 比较的结果都是 false。
console.log(NaN === NaN); // false
console.log(NaN == NaN); // false这是 IEEE 754 标准的一个规定，旨在表示 NaN 是一个不确定的值，即使两个 NaN 值看起来相同，它们也可能代表不同原因导致的“非数字”结果。
此外，NaN 与任何其他值进行比较（包括 Infinity、有限数，甚至是 undefined、null 等），结果都是 false，除了 !==。
console.log(NaN > 0); // false
console.log(NaN < 0); // false
console.log(NaN >= 0); // false
console.log(NaN <= 0); // false
console.log(NaN === 1); // false
console.log(NaN === null); // false
console.log(NaN === undefined); // false
console.log(NaN !== NaN); // true (这是判断NaN的一个技巧)3.5 NaN 的类型转换
-
String()转换：NaN转换为字符串"NaN"。console.log(String(NaN)); // "NaN" -
Boolean()转换：NaN是 JavaScript 中少数几个被视为假值 (false) 的值之一（其他包括false,0,-0,"",null,undefined）。console.log(Boolean(NaN)); // false if (NaN) { console.log("This will not be printed."); } else { console.log("NaN is falsy."); // NaN is falsy. } -
Number()转换：Number(NaN)仍然是NaN。console.log(Number(NaN)); // NaN -
parseInt()/parseFloat()转换：parseInt("NaN")和parseFloat("NaN")都返回NaN。console.log(parseInt("NaN")); // NaN console.log(parseFloat("NaN")); // NaN
3.6 判断 NaN 的方法
由于 NaN 不等于自身，所以不能使用 === NaN 或 == NaN 来判断一个值是否为 NaN。
-
Number.isNaN()：这是 ES6 引入的静态方法，是判断NaN的推荐方法。它不会尝试将参数转换为数字，只有当参数的类型是Number且值是NaN时才返回true。console.log(Number.isNaN(NaN)); // true console.log(Number.isNaN(0 / 0)); // true console.log(Number.isNaN(123)); // false console.log(Number.isNaN("NaN")); // false (因为 "NaN" 是字符串，不是数字 NaN) console.log(Number.isNaN("hello")); // false console.log(Number.isNaN(undefined)); // false -
全局函数
isNaN()：这个全局函数在判断NaN时，会首先尝试将参数转换为数字。如果转换后的结果是NaN，则返回true。这使得它在某些情况下行为不直观，容易出错。console.log(isNaN(NaN)); // true console.log(isNaN(0 / 0)); // true console.log(isNaN(123)); // false console.log(isNaN("NaN")); // true (因为它被转换为数字 NaN) console.log(isNaN("hello")); // true (因为它被转换为 NaN) console.log(isNaN("123")); // false (因为它被转换为数字 123) console.log(isNaN(undefined)); // true (undefined 被转换为 NaN) console.log(isNaN(null)); // false (null 被转换为 0) console.log(isNaN(true)); // false (true 被转换为 1)由于
isNaN()会对非数字类型进行隐式类型转换，导致例如isNaN("hello")返回true，这可能不是我们期望的行为。因此，通常推荐使用Number.isNaN()来进行更严格和准确的NaN判断。 -
x !== x技巧：由于NaN是唯一一个不等于自身的值，所以x !== x可以用来判断x是否为NaN。这种方法简洁有效，但可读性不如Number.isNaN()。let x = 0 / 0; console.log(x !== x); // true (x 是 NaN) let y = 123; console.log(y !== y); // false (y 不是 NaN)
NaN 行为总结表
| 运算类型 | 表达式示例 | 结果 | 备注 |
|---|---|---|---|
| 算术运算 | NaN + 5 |
NaN |
NaN 具有传染性，任何算术运算结果都是 NaN |
NaN * Infinity |
NaN |
||
NaN / NaN |
NaN |
||
| 比较 | NaN === NaN |
false |
NaN 不等于自身，这是其关键特性 |
NaN == NaN |
false |
||
NaN > 0 |
false |
NaN 与任何值都不进行有意义的比较 |
|
NaN < 0 |
false |
||
NaN >= 0 |
false |
||
NaN <= 0 |
false |
||
NaN === Infinity |
false |
||
NaN !== NaN |
true |
判断 NaN 的一种技巧 |
|
类型转换 Boolean |
Boolean(NaN) |
false |
NaN 是假值 |
类型转换 String |
String(NaN) |
"NaN" |
|
类型转换 Number |
Number(NaN) |
NaN |
第四章：IEEE 754 标准与 JavaScript 浮点数的深层联系
JavaScript 的 Number 类型完全遵循 IEEE 754 双精度浮点数标准。这意味着除了 Infinity 和 NaN，还有一些其他特性和考量。
4.1 浮点数的精度问题
由于浮点数表示的限制，JavaScript 中的某些小数运算可能会产生看似不准确的结果。这并非 JavaScript 特有，而是所有遵循 IEEE 754 标准的浮点运算的普遍现象。
console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3); // false这是因为十进制小数在二进制浮点数表示中可能无法精确表示，导致微小的误差。处理金融计算或需要高精度的场景时，通常需要使用专门的库（如 decimal.js 或 big.js）或将数字转换为整数进行计算。
4.2 符号零 (+0 和 -0)
IEEE 754 标准还定义了正零 (+0) 和负零 (-0)。在大多数情况下，它们被视为相等，但它们在某些操作中会表现出不同的行为，尤其是在涉及 Infinity 的除法中。
console.log(0 === -0); // true
console.log(0 == -0); // true
console.log(1 / 0); // Infinity
console.log(1 / -0); // -Infinity
console.log(Math.atan2(0, 1)); // 0
console.log(Math.atan2(-0, 1)); // -0虽然 +0 和 -0 在比较时相等，但它们的符号信息在某些数学运算中被保留。
4.3 Object.is() 在处理 NaN 和符号零时的特殊性
ES6 引入的 Object.is() 方法提供了一种严格的相等比较，它在处理 NaN 和符号零时与 === 运算符有所不同。
Object.is(NaN, NaN)返回true：这与===的行为相反，使得NaN可以与自身进行比较。Object.is(0, -0)返回false：这与===的行为相反，区分了正零和负零。
console.log(NaN === NaN); // false
console.log(Object.is(NaN, NaN)); // true
console.log(0 === -0); // true
console.log(Object.is(0, -0)); // false
console.log(Object.is(1, 1)); // true (与 === 相同)
console.log(Object.is(1, '1')); // false (与 === 相同，不进行类型转换)Object.is() 在许多方面类似于 ===，但它提供了更严格的相等性语义，在需要区分 NaN 和符号零的特定场景下非常有用。
4.4 位操作与 Infinity / NaN
JavaScript 的位操作符（如 &, |, ^, ~, <<, >>, >>>）只对 32 位带符号整数有效。当操作数不是 32 位整数时，它们会先被转换为 32 位整数。
Infinity 和 NaN 在转换为 32 位整数时，都会变成 0。
console.log(Infinity | 0); // 0
console.log(NaN | 0); // 0
console.log(1.5 | 0); // 1 (小数部分被截断)
console.log(-1.5 | 0); // -1这意味着在位操作的上下文中，Infinity 和 NaN 会失去其特殊含义，被视为零。
第五章：实际应用与最佳实践
理解 Infinity 和 NaN 的行为对于编写健壮的 JavaScript 代码至关重要。
5.1 错误处理与数据验证
在处理用户输入、解析外部数据（如 API 响应）或进行复杂计算时，总是有可能遇到 NaN 或 Infinity。
-
验证用户输入：如果用户输入应该是一个有限数字，务必进行检查。
function processNumericInput(input) { let num = Number(input); // 尝试将输入转换为数字 if (Number.isNaN(num)) { console.error("输入无效：不是一个数字。"); return null; } if (!Number.isFinite(num)) { console.error("输入无效：不是一个有限数字（可能是无穷大）。"); return null; } // 进一步处理有限数字 num console.log("有效数字：", num); return num; } processNumericInput("123"); // 有效数字：123 processNumericInput("hello"); // 输入无效：不是一个数字。 processNumericInput("Infinity"); // 输入无效：不是一个有限数字（可能是无穷大）。 processNumericInput(""); // 有效数字：0 (Number("") 是 0) processNumericInput(null); // 有效数字：0 (Number(null) 是 0) processNumericInput(true); // 有效数字：1 (Number(true) 是 1) -
避免计算结果为
NaN或Infinity：在执行可能导致这些特殊值的数学运算前，应检查操作数的有效性。function safeDivide(a, b) { if (Number.isNaN(a) || Number.isNaN(b)) { console.warn("除数或被除数是 NaN。"); return NaN; } if (!Number.isFinite(a) || !Number.isFinite(b)) { console.warn("除数或被除数是非有限数。"); // 根据具体业务逻辑处理，例如返回NaN，或者根据无穷大的规则计算 if (b === 0 && a !== 0) { // 有限非零数 / 0 = Infinity/-Infinity return a > 0 ? Infinity : -Infinity; } else if (a === 0 && b === 0) { // 0 / 0 = NaN return NaN; } else if (!Number.isFinite(a) && !Number.isFinite(b)) { // Infinity/Infinity = NaN return NaN; } else if (!Number.isFinite(a) || !Number.isFinite(b)) { // Infinity/finite, finite/Infinity return a / b; // 依靠JS内置行为 } } if (b === 0) { console.error("除数不能为零。"); return NaN; // 或者根据需求返回 Infinity/-Infinity } return a / b; } console.log(safeDivide(10, 2)); // 5 console.log(safeDivide(10, 0)); // 除数不能为零。 NaN console.log(safeDivide(0, 0)); // 除数或被除数是非有限数。 NaN console.log(safeDivide(10, NaN)); // 除数或被除数是 NaN。 NaN console.log(safeDivide(Infinity, 2)); // 除数或被除数是非有限数。 Infinity console.log(safeDivide(Infinity, Infinity)); // 除数或被除数是非有限数。 NaN上述
safeDivide函数展示了如何更细致地处理各种特殊情况，但实际应用中需要根据具体需求简化或调整。
5.2 避免常见陷阱
-
全局
isNaN()的误用：
由于isNaN()会进行隐式类型转换，isNaN("abc")返回true，isNaN(undefined)返回true。这往往不是我们想要的，我们通常只关心值本身是否是NaN。
最佳实践：始终使用Number.isNaN()。let value = "hello"; if (isNaN(value)) { console.log("全局 isNaN 认为 'hello' 是 NaN"); // 会执行 } if (Number.isNaN(value)) { console.log("Number.isNaN 认为 'hello' 是 NaN"); // 不会执行 } -
直接比较
NaN：
永远不要使用variable === NaN或variable == NaN来检查NaN，因为它们总是返回false。
最佳实践：使用Number.isNaN()或variable !== variable。let result = 0 / 0; if (result === NaN) { console.log("不会执行"); } if (result !== result) { console.log("使用 !== 技巧判断为 NaN"); // 会执行 } if (Number.isNaN(result)) { console.log("使用 Number.isNaN 判断为 NaN"); // 会执行 } -
忘记检查
Infinity：
虽然Infinity比NaN更直观，但在某些情况下，如计算平均值时分母为零，或处理非常大的数据集导致数值溢出时，Infinity可能会悄然出现。如果不加检查，可能会导致后续计算出现NaN或其他意外结果。
最佳实践：对于可能产生极大值的计算结果，使用Number.isFinite()进行验证。
5.3 代码示例：健壮的数值处理函数
以下是一个综合性的函数，用于验证一个值是否为有效的有限数字：
/**
* 检查一个值是否为有效的有限数字。
* - 排除 NaN 和 Infinity。
* - 排除非数字类型。
* @param {*} value - 待检查的值。
* @returns {boolean} - 如果是有效的有限数字，则返回 true，否则返回 false。
*/
function isValidFiniteNumber(value) {
// 1. 检查类型是否为 'number'
if (typeof value !== 'number') {
return false;
}
// 2. 检查是否为 NaN
if (Number.isNaN(value)) {
return false;
}
// 3. 检查是否为 Infinity 或 -Infinity
if (!Number.isFinite(value)) { // Number.isFinite 已经排除了 NaN，所以这里只剩 Infinity/-Infinity
return false;
}
// 如果通过以上所有检查，则是一个有效的有限数字
return true;
}
console.log("--- isValidFiniteNumber ---");
console.log("isValidFiniteNumber(123):", isValidFiniteNumber(123)); // true
console.log("isValidFiniteNumber(0.5):", isValidFiniteNumber(0.5)); // true
console.log("isValidFiniteNumber(-100):", isValidFiniteNumber(-100)); // true
console.log("isValidFiniteNumber(0):", isValidFiniteNumber(0)); // true
console.log("isValidFiniteNumber(NaN):", isValidFiniteNumber(NaN)); // false
console.log("isValidFiniteNumber(Infinity):", isValidFiniteNumber(Infinity));// false
console.log("isValidFiniteNumber(-Infinity):", isValidFiniteNumber(-Infinity));// false
console.log("isValidFiniteNumber('123'):", isValidFiniteNumber('123')); // false (字符串)
console.log("isValidFiniteNumber(null):", isValidFiniteNumber(null)); // false (null)
console.log("isValidFiniteNumber(undefined):", isValidFiniteNumber(undefined));// false (undefined)
console.log("isValidFiniteNumber(true):", isValidFiniteNumber(true)); // false (布尔值)
console.log("isValidFiniteNumber({}):", isValidFiniteNumber({})); // false (对象)
// 可以进一步封装一个用于安全转换的函数
function toSafeNumber(input) {
let num = Number(input);
if (isValidFiniteNumber(num)) {
return num;
}
// 根据业务需求，返回默认值、抛出错误或 null
console.warn(`无法将输入 '${input}' 转换为安全的有限数字，返回 NaN。`);
return NaN;
}
console.log("n--- toSafeNumber ---");
console.log("toSafeNumber('123'):", toSafeNumber('123')); // 123
console.log("toSafeNumber(' -45.6 '):", toSafeNumber(' -45.6 ')); // -45.6
console.log("toSafeNumber('abc'):", toSafeNumber('abc')); // 无法将输入 'abc' 转换为安全的有限数字，返回 NaN。 NaN
console.log("toSafeNumber(null):", toSafeNumber(null)); // 0
console.log("toSafeNumber(true):", toSafeNumber(true)); // 1
console.log("toSafeNumber('Infinity'):", toSafeNumber('Infinity')); // 无法将输入 'Infinity' 转换为安全的有限数字，返回 NaN。 NaN第六章：规范中的 Infinity 与 NaN
ECMAScript 语言规范详细定义了 JavaScript 中所有数据类型和操作符的行为，包括 Infinity 和 NaN。理解这些规范有助于我们更深入地理解其行为。
6.1 Number 类型和 IEEE 754
ECMAScript 规范明确指出，Number 类型的值是双精度 64 位格式的 IEEE 754-2019 标准浮点数。这直接导致了 Infinity、-Infinity 和 NaN 的存在，以及浮点数运算的精度特性。
6.2 ToNumber 抽象操作
许多内置函数和操作符在处理非 Number 类型的操作数时，会隐式地调用 ToNumber 抽象操作。这个操作定义了如何将各种类型的值转换为 Number 类型。
ToNumber(undefined)结果是NaN。ToNumber(null)结果是+0。ToNumber(true)结果是1，ToNumber(false)结果是+0。ToNumber(String)：如果字符串无法解析为有效数字，则结果是NaN。例如ToNumber("abc")->NaN。如果字符串是"Infinity"或"-Infinity"，则结果是对应的Infinity值。
这些规则解释了为什么 isNaN(undefined) 是 true（因为 undefined 被转换为 NaN），而 isNaN(null) 是 false（因为 null 被转换为 0）。
6.3 各种运算符的规范行为
ECMAScript 规范为每个运算符（如 +, -, *, /, %, ==, ===, >, <, >= 等）都定义了详细的算法，包括它们如何处理 Infinity、NaN 和符号零。这些算法确保了跨不同 JavaScript 引擎的一致行为。
例如，对于加法运算符 +，规范中会有类似以下的规则：
- 如果任一操作数是
NaN，则结果是NaN。 - 如果两个操作数都是
Infinity且符号相同，则结果是Infinity。 - 如果两个操作数都是
Infinity且符号相反，则结果是NaN。 - 如果一个操作数是
Infinity，另一个是有限数，则结果是Infinity（符号取决于Infinity的符号）。
这些规范细节是 JavaScript 中 Infinity 和 NaN 行为的最终权威解释。
Infinity 和 NaN 是 JavaScript 数值类型中不可或缺的组成部分，它们源于 IEEE 754 浮点数标准的严格定义。掌握它们的生成机制、独特的算术与比较行为，以及正确可靠的检测方法，是编写高质量、健壮 JavaScript 代码的关键。通过利用 Number.isFinite() 和 Number.isNaN() 等现代 API，开发者可以有效地处理这些特殊值，避免常见的陷阱，从而确保应用程序的稳定性和数据处理的准确性。