JavaScript 中的 NaN：一个“不是数字的数字”！

同学们，今天咱们来聊聊 JavaScript 中一个非常“奇葩”但又无处不在的特殊数值——NaN。

你可能经常见到它，但它却有着自己一套独特的“脾气”和“规矩”。搞不明白它，你可能会在代码里踩到一些意想不到的“坑”！

JavaScript 中的 `NaN`：一个“不是数字的数字”！

1. `NaN` 是什么？

NaN 全称是 "Not-a-Number"，直译过来就是“不是一个数字”。

听起来有点矛盾？别急，最关键的一点你要记住：

NaN 是一个特殊数值，它仍然属于 Number 类型！
- 你可以用 typeof NaN 来验证：
```
console.log(typeof NaN); // 输出: "number"
```
它就像 Number 家族里的一只“黑羊”，虽然是羊，但行为却很独特。

2. `NaN` 是如何产生的？

NaN 通常表示一个非法或无法表示的数值结果。它就像一个“失败的数学运算”或者“无法转换的数字”。

常见的产生场景有：

无效的数学运算：

任何涉及数学上无法确定的操作，例如：


console.log(0 / 0);          // NaN (零除以零，数学上不定式)
console.log(Infinity / Infinity); // NaN (无穷大除以无穷大)
console.log(Infinity - Infinity); // NaN (无穷大减无穷大)
console.log(Math.sqrt(-1));  // NaN (负数的平方根在实数范围内是无法表示的)
console.log(Math.log(-1));   // NaN (负数的对数)

尝试将非数字字符串转换为数字：

当 parseInt()、parseFloat() 或 Number() 函数尝试解析一个无法转换为有效数字的字符串时：


console.log(parseInt("hello"));    // NaN ("hello" 无法解析成数字)
console.log(Number("abc"));        // NaN ("abc" 无法转换为数字)
console.log(parseFloat("123a45")); // 123 (parseFloat 会解析直到遇到第一个非数字字符，这里得到 123，所以不是 NaN。
                                 // 但如果字符串开头就不是数字，比如 "a123"，就会是 NaN)
console.log(Number(undefined));    // NaN (undefined 转换为数字是 NaN)
console.log(Number({}));           // NaN (空对象转换为数字是 NaN)

注意：
- parseInt("123a") 结果是 123，因为它只解析到非数字字符为止。
- Number("123a") 结果是 NaN，因为它尝试将整个字符串转换为数字。
- Number(null) 是 0，Number(true) 是 1，Number([]) 是 0。这些都是有效数字，所以不是 NaN。

涉及 NaN 的任何算术运算：

一旦一个操作数是 NaN，大多数算术运算的结果也都会是 NaN。


console.log(NaN + 5);      // NaN
console.log(NaN * 10);     // NaN
console.log(NaN / 2);      // NaN
console.log(NaN - NaN);    // NaN

3. `NaN` 最独特的属性：`NaN !== NaN`！

这是 NaN 最“奇葩”也是最重要的一点！

在 JavaScript 中，NaN 是唯一一个不等于它自身的值！


console.log(NaN === NaN); // 输出: false
console.log(NaN == NaN);  // 输出: false

这就像一个“黑洞”，任何东西掉进去，都变得无法比较。你用 ==、===、>、<、>=、<= 任何比较运算符，只要其中一个操作数是 NaN，结果都会是 false。


const x = NaN;
const y = 5;

console.log(x === x);   // false
console.log(x == x);    // false
console.log(x > y);     // false
console.log(x < y);     // false
console.log(x >= y);    // false
console.log(x <= y);    // false
console.log(x === undefined); // false
console.log(x === null);      // false
console.log(x === "NaN");     // false (类型不同)

4. 如何正确地检测 `NaN`？

由于 NaN !== NaN 这个特性，你不能直接使用 == 或 === 来判断一个变量是否为 NaN。

JavaScript 提供了几种方法来检测 NaN：

isNaN(value) (全局函数 - 有坑！)

这是最老的方法，但它有一个很大的“坑”！
isNaN() 函数会首先尝试将传入的值转换为数字，如果转换失败，再检查转换后的结果是否为 NaN。

坑在哪里？


console.log(isNaN(NaN));       // true (正确)
console.log(isNaN(123));       // false (正确)
console.log(isNaN("hello"));   // true (因为 "hello" 无法转为数字，结果就是 NaN，所以返回 true。
                               // 但 "hello" 本身并不是 NaN！)
console.log(isNaN(undefined)); // true (undefined 转为数字是 NaN，所以返回 true)
console.log(isNaN({}));        // true (空对象转为数字是 NaN，所以返回 true)
console.log(isNaN("123"));     // false ("123" 可以转为数字 123，所以返回 false)

因此，isNaN() 不能严格地判断一个值是否就是 NaN 本身，它判断的是一个值**“是不是一个合法的数字”**。

Number.isNaN(value) (推荐！ES6+)

这是 ES6 (ECMAScript 2015) 引入的新方法，也是检测 NaN 的正确且推荐的方式！

Number.isNaN() 不会进行隐式类型转换。它只会在传入的值严格等于 NaN 的时候才返回 true。


console.log(Number.isNaN(NaN));       // true (正确)
console.log(Number.isNaN(123));       // false (正确)
console.log(Number.isNaN("hello"));   // false (正确，"hello" 不是 NaN)
console.log(Number.isNaN(undefined)); // false (正确，undefined 不是 NaN)
console.log(Number.isNaN({}));        // false (正确，{} 不是 NaN)
console.log(Number.isNaN("123"));     // false (正确，"123" 不是 NaN)

结论： 除非你真的需要检测一个值“是否可以被解析为一个合法数字”，否则请总是使用 Number.isNaN() 来判断一个值是否就是 NaN 本身。

利用 NaN !== NaN 的特性 (小技巧)
- 这是一种古老的、利用 NaN 独特属性的方法，在 Number.isNaN() 不被支持的旧环境中有用，但可读性不如 Number.isNaN()。
```
const myValue = 0 / 0; // myValue 是 NaN

if (myValue !== myValue) {
  console.log("myValue 是 NaN！");
} else {
  console.log("myValue 不是 NaN！");
}
```

5. `NaN` 作为 Falsy 值

在 JavaScript 中，NaN 是一个 falsy 值（假值），这意味着当它在布尔上下文中被评估时，会被视为 false。

  
if (NaN) {
  
  console.log("这不会被执行");
  
} else {
  
  console.log("NaN 在布尔上下文中是 falsy"); // 输出: NaN 在布尔上下文中是 falsy
  
}

JavaScript 中常见的 falsy 值包括：false、0、"" (空字符串)、null、undefined 和 NaN。

6. 总结与常见误区

NaN 是 Number 类型！ 虽然叫“不是数字”，但它骨子里是数字。
NaN 不等于它自己！ 这是最重要的特性，也是区分它和所有其他值的方式。
不要用 isNaN() (全局) 来严格判断 NaN！ 它会进行类型转换。
请使用 Number.isNaN() 来严格判断 NaN！ 这是 ES6+ 的标准做法，精确无误。
NaN 是一个 falsy 值。
NaN 的出现通常意味着你的数学运算是无效的，或者你的数据转换失败了。在调试时，如果看到 NaN，通常需要回溯数据来源和计算过程。

理解 NaN 的这些特性，能帮助你避免很多潜在的 Bug，写出更健壮的 JavaScript 代码！

JavaScript 中的 NaN：一个“不是数字的数字”！