分析 `JavaScript` `NaN` 和 `typeof NaN` 的特殊性，以及 `IEEE 754` 双精度浮点数标准对 `JavaScript` 数字计算的影响。

各位靓仔靓女，晚上好！我是你们的老朋友，今天咱们来聊聊 JavaScript 里面的一个奇葩玩意儿——NaN，以及它背后的故事，还有 IEEE 754 标准这个幕后黑手。保证让你们听完之后，对 JavaScript 的数字世界有更深刻的认识，以后遇到妖魔鬼怪也能淡定应对。

第一幕：NaN的身世之谜

首先，我们得认识一下 NaN 这个家伙。它的全称是 "Not a Number"，字面意思就是“不是一个数字”。但问题来了，如果它不是一个数字，那它是什么？

在 JavaScript 中，NaN 实际上是一个属于 Number 类型的值。是不是有点绕？别急，咱们慢慢来。

想象一下，你在做一些数学运算，但是结果根本无法用数字来表示。比如：

0 除以 0： 0 / 0
对负数开平方根： Math.sqrt(-1)
尝试将无法转换为数字的字符串转换为数字： parseInt("hello")

这些操作都会产生 NaN。简单来说，NaN 是 JavaScript 用来表示无效或未定义数学运算结果的一种方式。

console.log(0 / 0);      // 输出：NaN
console.log(Math.sqrt(-1)); // 输出：NaN
console.log(parseInt("hello")); // 输出：NaN

第二幕：typeof NaN 的迷惑行为

重点来了！敲黑板！

既然 NaN 的全称是 "Not a Number"，那么 typeof NaN 应该是什么呢？

console.log(typeof NaN); // 输出：number

WHAT?! typeof NaN 居然是 number！这简直是 JavaScript 最大的谎言之一！

这其实是 JavaScript 的一个历史遗留问题，也是很多初学者感到困惑的地方。虽然 NaN 表示“不是一个数字”，但它仍然被归类为 Number 类型。你可以把它理解为 Number 类型的一个特殊值，用来表示那些无法用正常数字表示的结果。

第三幕：NaN 的古怪特性

NaN 不仅身世奇特，它的行为也相当古怪。最让人抓狂的就是，NaN 和任何值（包括它自己）都不相等！

console.log(NaN == NaN);      // 输出：false
console.log(NaN === NaN);     // 输出：false
console.log(NaN == 1);        // 输出：false
console.log(NaN == 'hello');  // 输出：false

这也就是说，你不能用 == 或 === 来判断一个值是否是 NaN。那么，应该怎么判断呢？ JavaScript 提供了一个全局函数 isNaN() 来解决这个问题。

console.log(isNaN(NaN));      // 输出：true
console.log(isNaN(123));      // 输出：false
console.log(isNaN("hello"));  // 输出：true (因为 "hello" 无法转换为数字)
console.log(isNaN("123"));    // 输出：false (因为 "123" 可以转换为数字)

但是，isNaN() 函数也有它的坑。它会尝试将传入的值转换为数字，如果转换失败，则返回 true。这可能会导致一些意想不到的结果。

console.log(isNaN("hello"));  // 输出：true
console.log(isNaN({}));       // 输出：true
console.log(isNaN([1, 2]));   // 输出：true (数组会被转换为字符串 "1,2"，然后转换失败)
console.log(isNaN(null));     // 输出：false (null 会被转换为 0)
console.log(isNaN(undefined)); // 输出：true (undefined 会被转换为 NaN)

为了更准确地判断一个值是否是 NaN，ES6 引入了一个新的函数 Number.isNaN()。它不会进行类型转换，只有当传入的值确实是 NaN 时，才会返回 true。

console.log(Number.isNaN(NaN));      // 输出：true
console.log(Number.isNaN(123));      // 输出：false
console.log(Number.isNaN("hello"));  // 输出：false
console.log(Number.isNaN({}));       // 输出：false
console.log(Number.isNaN(null));     // 输出：false
console.log(Number.isNaN(undefined)); // 输出：false

所以，在判断 NaN 时，推荐使用 Number.isNaN() 函数。

第四幕：IEEE 754 标准的幕后操纵

现在，让我们把目光投向更深层次的原因。为什么 JavaScript 会有 NaN 这种奇葩玩意儿？这就要归功于 IEEE 754 标准了。

IEEE 754 是一个关于浮点数算术的标准，它定义了浮点数的存储格式和运算规则。 JavaScript 中的 Number 类型实际上是基于 IEEE 754 双精度浮点数格式（也称为 double）来实现的。

IEEE 754 标准使用有限的位数来表示无限的实数。这意味着，有些实数无法被精确地表示，只能用近似值来代替。这就会导致一些意想不到的精度问题。

console.log(0.1 + 0.2); // 输出：0.30000000000000004

为什么 0.1 + 0.2 不等于 0.3 呢？这就是因为 0.1 和 0.2 这两个小数无法被 IEEE 754 精确地表示，只能用近似值来代替。当这两个近似值相加时，结果就不是精确的 0.3，而是 0.30000000000000004。

IEEE 754 标准还定义了 NaN、正无穷大 (Infinity) 和负无穷大 (-Infinity) 这三个特殊值。它们用来表示一些特殊的运算结果，比如除以 0、溢出等等。

console.log(1 / 0);        // 输出：Infinity
console.log(-1 / 0);       // 输出：-Infinity
console.log(Number.MAX_VALUE * 2); // 输出：Infinity

第五幕：IEEE 754 对 JavaScript 数字计算的影响

IEEE 754 标准对 JavaScript 的数字计算产生了深远的影响。它不仅导致了精度问题和特殊值的出现，还影响了 JavaScript 的比较运算和类型转换。

精度问题： 由于浮点数的精度有限，所以在进行浮点数运算时，一定要注意精度问题。尽量避免直接比较两个浮点数是否相等，而是应该比较它们的差值是否在一个很小的范围内。
```
const a = 0.1 + 0.2;
const b = 0.3;

// 错误的做法
console.log(a == b); // 输出：false

// 正确的做法
const epsilon = 0.0000001; // 定义一个很小的误差范围
console.log(Math.abs(a - b) < epsilon); // 输出：true
```

特殊值： 要学会处理 NaN、Infinity 和 -Infinity 这些特殊值。使用 Number.isNaN() 函数来判断一个值是否是 NaN，使用 isFinite() 函数来判断一个值是否是有限数。

console.log(Number.isNaN(NaN));      // 输出：true
console.log(isFinite(123));        // 输出：true
console.log(isFinite(Infinity));     // 输出：false
console.log(isFinite(-Infinity));    // 输出：false

类型转换： 在进行类型转换时，要注意 IEEE 754 标准的影响。例如，将字符串转换为数字时，如果字符串无法转换为有效的数字，则会得到 NaN。
```
console.log(Number("hello")); // 输出：NaN
```

第六幕：总结与建议

好了，讲了这么多，相信大家对 JavaScript 中的 NaN 和 IEEE 754 标准已经有了更深入的了解。最后，给大家一些建议：

了解 NaN 的本质： NaN 是 Number 类型的一个特殊值，用来表示无效或未定义的数学运算结果。
使用 Number.isNaN() 函数： 使用 Number.isNaN() 函数来准确地判断一个值是否是 NaN。
注意浮点数的精度问题： 在进行浮点数运算时，要注意精度问题，尽量避免直接比较两个浮点数是否相等。
学会处理特殊值： 学会处理 NaN、Infinity 和 -Infinity 这些特殊值，使用 isFinite() 函数来判断一个值是否是有限数。
了解 IEEE 754 标准： 了解 IEEE 754 标准，可以帮助你更好地理解 JavaScript 的数字计算。

一些常见问题的总结：

问题	解决方法
如何判断一个值是否是 `NaN`？	使用 `Number.isNaN()` 函数。
为什么 `0.1 + 0.2` 不等于 `0.3`？	这是因为浮点数的精度有限，`0.1` 和 `0.2` 无法被精确地表示。
如何避免浮点数的精度问题？	尽量避免直接比较两个浮点数是否相等，而是应该比较它们的差值是否在一个很小的范围内。
如何处理 `Infinity` 和 `-Infinity`？	使用 `isFinite()` 函数来判断一个值是否是有限数。
字符串转换为数字时，如何避免得到 `NaN`？	在转换之前，先使用正则表达式或其他方法来验证字符串是否可以转换为有效的数字。

掌握了这些知识，相信大家在 JavaScript 的数字世界里可以更加游刃有余，不再被 NaN 这种奇葩玩意儿所困扰。

今天的讲座就到这里，希望对大家有所帮助！感谢各位的聆听！我们下次再见！

发表回复 取消回复

发表回复取消回复