那些意想不到的代码

1. 有趣的数字比较

0 >= null  //  true
0 <= null  // true

// 因为两者在进行抽象相等比较时都被转换成了0或false
0 == false // true
0 == [] // true

2. for循环

for ... of循环和for ... in循环由于历史遗留问题，它遍历的实际上是对象的属性名称。一个Array数组实际上也是一个对象，它的每个元素的索引被视为一个属性。

var arr = ['a','b','c’]
arr.name = ‘it'
for (var x in arr) {
    alert(x) // '0' '1' '2' ‘name'
}

for (var x of arr) {
    alert(arr[x]) // 'a' 'b' 'c'
}

for ... in循环将把name包括在内，但Array的length属性却不包括在内

3. map和parseInt的结合

['1','2','3'].map(parseInt); //[1, NaN, NaN]

parseInt 接受两个参数，第二个参数是进制基数。在 map 中，传入的第二个参数实际上是数组索引。因此，parseInt('1', 0) 返回 1，parseInt('2', 1) 返回 NaN（因为基数 1 是非法的），parseInt('3', 2) 返回 NaN。

4. setTimeout

for(var i = 0; i < 10; i++) {
  setTimeout(function() {
    console.log(i); // 输出10十次，而不是预期的0到9
  }, 100);
}

for(let i = 0; i < 10; i++) {
  setTimeout(function() {
    console.log(i); // 输出0 1 2 3 4 5 6 7 8 9
  }, 100);
}

var 是函数作用域，而不是块作用域，因此在循环结束时 i 的值是 10，所以输出十次 10。如果改用 let，每次 i 的值会保持在当前的块作用域中，输出会是 0, 1, 2，3，4，5，6，7，8，9。

5. 自动类型转换的陷阱

[] + {}; // [object Object]
{} + []; // 0

[1] + 1; // '11'
[1,2] + [3,4]; // '1,23,4'

数组通过 + 运算符转换为字符串，然后进行字符串拼接。

6. 浮点数精度问题

console.log(0.1 + 0.2); // 0.30000000000000004

由于浮点数在计算机中的表示方式，某些运算结果并不是预期的精确值。

7. typeof的奇怪结果

console.log(typeof null); // 'object'

null 实际上不是对象，但由于历史原因，typeof null 返回 'object'。

8. 空数组与空对象的比较

console.log([] == []); // false
console.log([] === []); // false
console.log({} == {}); // false
console.log({} === {}); // false

数组和对象在比较时比较的是引用，而不是内容，所以不同的空数组和对象不会相等。

9. 数字加字符串

console.log(1 + '2'); // '12'
console.log(1 - '2'); // -1

在加法操作中，数字会被转换为字符串并进行字符串连接，而减法会将字符串转换为数字。

10. isNaN 的奇怪表现

console.log(isNaN('Hello')); // true
console.log(isNaN('123')); // false
console.log(isNaN(true)); // false

isNaN 会先将参数转换为数字，然后判断是否是 NaN。所以 'Hello' 不能被转换为数字，返回 true，但 '123' 可以被转换为数字 123，因此返回 false。

11. Number 对象的奇怪转换

console.log(Number(null)); // 0
console.log(Number(undefined)); // NaN

Number 对象会将 null 转换为 0，而 undefined 会被转换为 NaN。

12. NaN 是唯一一个不等于自身的值

console.log(NaN === NaN); // false

NaN（Not-a-Number）被设计成不等于任何值，包括它自己。

13. 负零

console.log(0 === -0); // true
console.log(1 / 0 === 1 / -0); // false

在 JavaScript 中，0 和 -0 在比较时相等，但它们在除法运算中会产生不同的结果。

14. Object.is 与 === 的差异

console.log(Object.is(NaN, NaN)); // true
console.log(NaN === NaN); // false

console.log(Object.is(+0, -0)); // false
console.log(+0 === -0); // true

Object.is 更精确地判断相等性，它认为 NaN 与 NaN 相等，+0 和 -0 不相等，而 === 不具备这些细微的判断。

15. sort排序

let arr = [10, 2, 5, 30];
arr.sort();
console.log(arr); // [10, 2, 30, 5]

默认情况下，sort 方法会将数组中的元素转换为字符串，再按字典顺序排序。这就是为什么 10 会排在 2 的前面。

16. 无穷大 Infinity

console.log(1 / 0); // Infinity
console.log(-1 / 0); // -Infinity
console.log(Infinity - Infinity); // NaN

在 JavaScript 中，Infinity 是一个合法值，代表无穷大。计算中某些情况会导致 NaN，例如 Infinity - Infinity。