显式类型转换（手动转换）

显式转换就是开发者主动进行的类型转换，就像你明确告诉JavaScript：”把这个值转换成XX类型！”

1. 转换为字符串（String）

将其他类型转换为字符串：

String(123);        // "123"
String(true);       // "true"
String(null);       // "null"
String(undefined);  // "undefined"
String({});         // "[object Object]"

更常用的方法：

let num = 10;
num.toString();     // "10"（注意：null和undefined不能用）

2. 转换为数字（Number）

将其他类型转换为数字：

Number("123");      // 123
Number("12.3");     // 12.3
Number("");         // 0
Number("  ");       // 0
Number(true);       // 1
Number(false);      // 0
Number(null);       // 0
Number(undefined);  // NaN（Not a Number）
Number("123abc");   // NaN

其他方法：

parseInt("10");      // 10（整数）
parseInt("10.5");    // 10（去掉小数部分）
parseInt("10px");    // 10（忽略非数字部分）
parseFloat("10.5");  // 10.5（保留小数）

+"123";             // 123（一元加号运算符）

3. 转换为布尔值（Boolean）

将其他类型转换为布尔值：

Boolean(1);          // true
Boolean(0);          // false
Boolean("");         // false
Boolean(" ");        // true（空格也是字符）
Boolean("hello");    // true
Boolean(null);       // false
Boolean(undefined);  // false
Boolean({});         // true
Boolean([]);         // true

更简洁的方式（双感叹号）：

!!0;        // false
!!"hello";  // true
!!null;     // false

隐式类型转换（自动转换）

隐式转换是JavaScript在特定上下文中自动进行的类型转换，就像JavaScript在”帮你”转换类型，但有时会带来意想不到的结果。

1. 字符串拼接

当使用+运算符时，如果有一个操作数是字符串，另一个操作数会被转换为字符串：

"5" + 1;        // "51"（数字1被转成字符串）
"5" + true;      // "5true"
"5" + null;      // "5null"
"5" + undefined; // "5undefined"
"5" + {};        // "5[object Object]"

2. 数学运算

除了+以外的数学运算符（-, *, /, %）会将操作数转换为数字：

"5" - 2;        // 3
"5" * "2";      // 10
"10" / "2";     // 5
"10" - "x";     // NaN（无法转换为数字）

3. 一元运算符

一元加号+和一元减号-会尝试将操作数转换为数字：

+true;     // 1
+false;    // 0
+"10";     // 10
+"";       // 0
+"  ";     // 0
+null;     // 0
+undefined; // NaN

4. 逻辑运算符

在逻辑运算中，值会被隐式转换为布尔值：

if (0) { /* 不会执行 */ }
if ("hello") { /* 会执行 */ }

let name = "";
name || "匿名";  // "匿名"（因为""是falsy）

5. 对象转换

当对象参与运算时，JavaScript会尝试调用对象的valueOf()或toString()方法：

let obj = {};
obj + 10;  // "[object Object]10"

obj = {
    valueOf: function() { return 42; }
};
obj + 10;  // 52

obj = {
    toString: function() { return "100"; }
};
obj + 10;  // "10010"

比较运算中的类型转换

在比较操作中，JavaScript也会进行类型转换，这常常是bug的来源。

1. 相等运算符（==）

==运算符会在比较前进行类型转换：

1 == "1";        // true（字符串转数字）
0 == false;      // true（布尔值转数字）
"" == false;     // true（两边都转成0）
null == undefined; // true（特殊规则）

0 == "";        // true（都转成0）
0 == "0";       // true
false == "0";   // true
null == 0;      // false（特殊规则）
[] == 0;        // true（数组转成空字符串，再转成0）
[] == false;    // true

2. 严格相等运算符（===）

===运算符不会进行类型转换：

1 === "1";        // false（类型不同）
0 === false;      // false（类型不同）
"" === false;     // false（类型不同）
null === undefined; // false（类型不同）

3. 比较运算符（>, <, >=, <=）

这些运算符会将操作数转换为数字（如果都是字符串则按字母顺序比较）：

"10" > 5;        // true（字符串转数字）
"10" > "5";      // false（字符串比较，'1' < '5'）
"abc" > "abd";   // false（按字母顺序比较）

特殊值比较表

类型转换注意事项

let user = {
    name: "John",
    money: 1000,
    [Symbol.toPrimitive](hint) {
        return hint == "string" ? this.name : this.money;
    }
};

alert(user);     // "John"（hint是"string"）
alert(+user);    // 1000（hint是"number"）

[] + [];         // ""（空字符串）
[] + {};         // "[object Object]"
{} + [];         // 0（被解释为空代码块加数组）
[1,2] == "1,2"; // true（数组转字符串）

类型转换总结

JavaScript类型转换的核心规则可以简化为：

1. 当需要字符串时：调用toString()
2. 当需要数字时：调用valueOf()或toString()
3. 当需要布尔值时：检查是否为falsy值

理解这些规则能帮助你写出更健壮、更少bug的代码！