序言

在编程的世界里，数据类型就像是各种语言中的词汇——它们定义了我们可以用代码表达的内容和方式。而在JavaScript这门充满活力且不断进化的语言中，类型转换就像是隐藏在代码背后的魔法师，悄无声息地改变着值的形式，让程序得以顺畅运行。但就像任何强大的魔法一样，如果使用不当，它也可能带来意想不到的结果。

你是否曾经遇到过这样的情况：当你试图将两个看似相同的值相加时，得到的结果却完全出乎意料？或者，在进行条件判断时，发现某些逻辑似乎“莫名其妙”地生效或失效？如果你的回答是肯定的，那么这篇文章就是为你量身定做的！

今天，我们将一起深入探讨JavaScript中的类型转换这一核心概念。通过理解不同类型之间的转换规则、隐式与显式转换的区别，以及如何避免常见的陷阱，你不仅能够编写更健壮、更可预测的代码，还能像真正的魔法师一样，自如地驾驭这些变化莫测的数据类型。

准备好了吗？让我们揭开JavaScript类型转换的神秘面纱，探索那些使你的代码更加灵活和强大的技巧吧！

在学习JavaScript的类型转换首先你要搞清楚三个问题：为何JS的类型会改变？、为何说JS是弱类型语言？和JS有多少种数据类型？在了解完这三个问题后我想你很快就能理解何为JS的类型转换。下面由我来解答这三个问题。

为何说JS是弱类型语言？

JavaScript 被称为弱类型语言（也称动态类型语言），主要是因为它具有以下特性：

1. 变量无需显式声明类型

在JavaScript中，你不需要在定义变量时指定其类型。例如，你可以简单地使用let或var来声明一个变量，并直接赋值，而无需关心这个值是什么类型。

let message = "Hello, World!";
message = 42; // 这里可以重新赋值为数字类型，无需改变变量声明

2. 自动类型转换

JavaScript会自动在某些情况下进行类型转换，以适应运算符或函数的需求。这种行为有时被称为“隐式类型转换”。例如，当你将字符串和数字相加时，JavaScript会自动将数字转换为字符串，然后执行字符串连接操作。

console.log("5" + 3); // 结果是 "53"

3. 松散的类型比较

JavaScript允许使用松散等于运算符==来进行不严格的类型比较。这意味着即使两个值的类型不同，只要它们在某种意义上“等价”，就会被认为是相等的。然而，这可能会导致一些意外的结果，因为JavaScript会在比较之前尝试转换这些值。

console.log(0 == ""); // true，因为空字符串被转换为数值0
console.log(null == undefined); // true，null和undefined被认为是等价的

4. 动态类型系统

JavaScript拥有动态类型系统，这意味着同一个变量可以在程序的不同部分持有不同类型的数据。变量的类型是在运行时确定的，而不是编译时。

let value;
value = "I am a string"; // 现在value是字符串类型
value = 100;            // 现在value是数字类型
value = false;          // 现在value是布尔类型

弱类型的优点与缺点

优点：

编写代码更快，因为你不必担心类型。

更灵活，尤其是在快速原型开发或者脚本编写中。

缺点：

容易出现错误，特别是在处理复杂逻辑时，由于类型转换可能导致难以追踪的问题。

性能上可能不如强类型语言优化得那么好，因为需要额外的类型检查和转换。

正因为上述特点，JavaScript被认为是一种弱类型语言。不过值得注意的是，“弱类型”并不意味着“不好”；它只是反映了语言设计哲学的一部分，旨在提供更大的灵活性和简化编程过程。对于开发者来说，理解并正确运用JavaScript的类型系统是非常重要的。

为何JS的类型会改变？

JavaScript中的类型会改变（即类型转换或类型强制转换）主要是为了使语言更加灵活，并允许开发者以更简便的方式编写代码。然而，这种灵活性有时也会带来一些意想不到的行为。类型改变可以分为隐式转换和显式转换两种情况。

隐式转换

隐式转换是指JavaScript在某些情况下自动将一个数据类型转换为另一个类型。这通常发生在以下几种情形：

运算符作用：当使用像加号+、减号-等运算符时，如果操作数的类型不兼容，JavaScript会尝试转换它们。例如，在字符串与数字之间进行加法运算时，数字会被转换成字符串。

console.log("5" + 3); // 结果是 "53"

比较操作：当使用松散等于运算符==或不等于运算符!=时，JavaScript会在比较之前尝试将两个值转换成相同的类型。

console.log(0 == ""); // true，因为0被转换为空字符串""

布尔上下文：在条件语句（如if语句）中，JavaScript会将非布尔类型的值转换为布尔值来判断真假。

if ("") {
    console.log("非空字符串");
} else {
    console.log("空字符串"); // 输出 "空字符串"
}

显式转换

显式转换则是由开发者明确地控制，通过调用特定的方法或构造函数来进行。这种方式使得意图更加清晰，避免了潜在的误解。

let num = Number("42"); // 字符串转数字
let str = String(42);   // 数字转字符串
let bool = Boolean(""); // 空字符串转布尔值 (结果为 false)

为何需要类型转换？

简化开发：JavaScript作为一门动态类型语言，它允许你不必严格指定变量的数据类型，这可以在一定程度上加快开发速度。

增强表达力：有时候，类型转换可以让代码看起来更加直观。例如，将数字直接添加到字符串末尾形成一个新的字符串，而无需额外的格式化步骤。

适应性：由于JavaScript广泛应用于Web浏览器环境中，它必须能够处理来自各种来源的数据，这些数据可能具有不同的格式和类型。有效的类型转换可以帮助程序更好地适应这些变化。

注意事项

虽然类型转换增加了语言的灵活性，但它也可能导致不易察觉的错误。因此，建议尽量使用显式转换，保持代码的可读性和可维护性。同时，在做类型检查时优先考虑严格相等运算符===而不是松散相等运算符==，以减少意外的类型转换带来的问题。

JS有多少种数据类型？

JavaScript 支持多种数据类型，可以分为基本类型（Primitive Types)和引用类型（Reference Types) 两大类。以下是详细的分类：

原始类型（简单数据类型）

原始类型是按值存储的简单数据片段，它们包括：

undefined：当一个变量被声明但未赋值时，默认值为undefined。

null：表示空值或不存在的对象。它是一个独立的类型，代表“无”或“没有对象”。

boolean：逻辑值，只有两个值：true 和 false。

number：用于表示整数和浮点数，也包括特殊的数值如 Infinity, -Infinity, 和 NaN (Not-a-Number)。

bigint：ES2020引入的新类型，用于表示任意精度的整数，允许使用比 number 更大的整数。

string：字符序列，例如 "Hello, World!"。

symbol：ES6引入的一种新原始数据类型，创建唯一的标识符。

引用类型（复杂数据类型）

引用类型是指向内存中对象的数据类型，主要包括：

object：这是最通用的引用类型，包括普通对象、数组、函数等。

普通对象：键值对集合，例如 { name: "Alice", age: 30 }。

数组：有序列表，例如 [1, 2, 3]。

日期：如 new Date()。

正则表达式：如 /pattern/。

错误对象：如 new Error("Oops!")。

特殊情况

NaN：虽然 NaN(not a number) 表面上看起来像是一种特殊类型，但它实际上是 number 类型的一个特殊值。

Infinity 和 -Infinity：同样，这两个都是 number 类型的特殊值。

1.number

在JavaScript中，number 是一种基本数据类型，用于表示数值（包括整数和浮点数）。当涉及到与其他基本数据类型的转换时，number 类型的值会根据上下文进行相应的转换。以下是 number 在不同类型转换中的表现：

1. 隐式转换

转换为布尔值（Boolean）

数字 0, -0, NaN 被视为假值（falsy），其他所有数字（包括正数、负数、无穷大）被视为真值（truthy）。

if (0) {
    console.log("This will not run");
} else {
    console.log("0 is falsy"); // 输出: 0 is falsy
}

if (42) {
    console.log("Non-zero numbers are truthy"); // 输出: Non-zero numbers are truthy
}

转换为字符串（String）

当 number 类型的值出现在字符串拼接操作中，或者显式地被转换为字符串时，它会被转换成对应的字符串形式。

console.log(42 + ""); // 输出: "42"
console.log(String(3.14)); // 输出: "3.14"

转换为对象（Object）

使用 Number 构造函数创建一个新的 Number 对象。

let numObj = new Number(42);
console.log(typeof numObj); // 输出: "object"

2. 显式转换

使用构造函数或全局方法

console.log(Number());          // 0 因为没有提供参数，默认返回0
console.log(Number(undefined));  // NaN 因为 undefined 在数值上下文中没有转成一个特定数值的含义
console.log(Number(null));      // 0 因为 null 被视为不存在的数值，转换为0
console.log(Number(true));      // 1 因为 true 转换为1
console.log(Number(false));     // 0 因为 false 转换为0

// 字符串转换
console.log(Number('123'));     // 123 字符串中的有效整数被转换为对应的数值
console.log(Number('-123'));    // -123 字符串中的有效负整数被转换为对应的数值
console.log(Number('0x11'));    // 17 十六进制字符串被正确解析并转换为十进制数值
console.log(Number(""));        // 0 空字符串被转换为0
console.log(Number(" "));       // 0 包含空白字符的字符串也被转换为0
console.log(Number("100a"));    // NaN 非数字字符导致无法解析，结果为NaN
console.log(Number("  42  "));  // 42 前后有空格的数字字符串会被正确解析

// 浮点数和科学计数法
console.log(Number('3.14'));    // 3.14 字符串中的浮点数被转换为对应的数值
console.log(Number('1e5'));     // 100000 科学计数法表示的字符串被正确解析

// 特殊字符和无效输入
console.log(Number('Infinity')); // Infinity 字符串 "Infinity" 被转换为 Infinity
console.log(Number('-Infinity'));// -Infinity 字符串 "-Infinity" 被转换为 -Infinity
console.log(Number('NaN'));     // NaN 字符串 "NaN" 被转换为 NaN
console.log(Number('hello'));   // NaN 非数字字符串导致无法解析，结果为 NaN

// 对象转换
console.log(Number({}));        // NaN 空对象无法转换为数值
console.log(Number([]));        // 0 空数组被视为0
console.log(Number([1]));       // 1 单元素数组转换为该元素的数值
console.log(Number([1, 2]));    // NaN 多元素数组无法转换为单一数值

// 其他类型
console.log(Number(new Date())); // 返回从1970年1月1日到当前日期的毫秒数

解释

浮点数和科学计数法：展示了如何处理包含小数点的字符串以及科学计数法格式的字符串。

特殊字符和无效输入：增加了对特殊字符（如 Infinity, -Infinity, NaN）和完全无效输入（如 "hello"）的处理。

对象转换：介绍了当传入对象时的行为，包括空对象、空数组、单元素数组和多元素数组。

其他类型：例如 Date 对象，它会返回自1970年1月1日以来的毫秒数。

3. 特殊场景下的转换

比较操作符

console.log(42 == "42"); // true
console.log(42 == "42.0"); // true
console.log(42 == "hello"); // false, 因为 "hello" 转换为 NaN

在严格比较 (===) 中，不仅比较值还要比较类型，因此不同类型的值即使数值相同也不会相等。

console.log(42 === "42"); // false

加法运算符

如果加法运算符的一侧是字符串，则另一侧会被转换为字符串并进行字符串连接。

console.log("The answer is " + 42); // 输出: "The answer is 42"

如果两侧都是数值或者可以被转换成数值，则执行数值相加。

console.log(5 + 7); // 输出: 12

其他运算符

减法、乘法、除法等算术运算符总是将操作数转换为数值后再进行计算。

console.log("5" - 2); // 输出: 3
console.log("10" * "2"); // 输出: 20

2.string

1. 隐式转换

转换为布尔值（Boolean）

空字符串 ("") 被视为假值（falsy），所有非空字符串（包括仅包含空白字符的字符串）被视为真值（truthy）。

if ("") {
    console.log("This will not run");
} else {
    console.log("Empty string is falsy"); // 输出: Empty string is falsy
}

if (" ") {
    console.log("Non-empty string is truthy"); // 输出: Non-empty string is truthy
}

转换为数字（Number）

字符串会被尝试解析为数值。如果解析成功，则返回对应的数值；否则返回 NaN。

console.log(Number("42"));        // 42
console.log(Number("-3.14"));     // -3.14
console.log(Number("0x1A"));      // 26 (十六进制)
console.log(Number("Infinity"));  // Infinity
console.log(Number("hello"));     // NaN
console.log(Number("42a"));       // NaN
console.log(Number(""));          // 0
console.log(Number(" "));         // 0

转换为对象（Object）

使用 String 构造函数创建一个新的 String 对象。

let strObj = new String("Hello");
console.log(typeof strObj); // 输出: "object"

2. 显式转换

使用构造函数或全局方法

console.log(String());                  // '' 空参数返回空字符串
console.log(String(123));               // '123' 数字被转换为对应的字符串表示形式
console.log(String(undefined), typeof String(undefined)); // 'undefined', 'string' undefined 被转换为字符串 "undefined"
console.log(String(null), typeof String(null));           // 'null', 'string' null 被转换为字符串 "null"
console.log(String(-0), String(+0));    // '0', '0' -0 和 +0 都被转换为字符串 "0"
console.log(String(NaN));               // 'NaN' NaN 被转换为字符串 "NaN"
console.log(String(true));              // 'true' 布尔值 true 被转换为字符串 "true"
console.log(String(false));             // 'false' 布尔值 false 被转换为字符串 "false"

console.log(String("hello"));           // 'hello' 字符串保持不变
console.log(String([1, 2, 3]));         // '1,2,3' 数组元素被连接成一个字符串，用逗号分隔
console.log(String({}));                // "[object Object]" 对象默认转换为 "[object Object]"
console.log(String([]));                // "" 空数组被转换为空字符串
console.log(String(new Date()));        // 当前日期时间的字符串表示形式
console.log(String(function() {}));     // 'function () {}' 函数被转换为其源代码字符串表示形式

解释

空对象 {} ：默认情况下，String({}) 返回 "[object Object]"，这是 JavaScript 中对象的默认字符串表示形式。

空数组 [] ：空数组被转换为空字符串 ""。

空参数：当 String() 没有提供参数时，默认返回空字符串 ''。

数字：数字（包括正数、负数和零）会被转换为相应的字符串表示形式。

undefined 和 null：这两个特殊值分别被转换为字符串 "undefined" 和 "null"。

-0 和 +0：无论是 -0 还是 +0，都被转换为字符串 "0"。

NaN：NaN 被转换为字符串 "NaN"。

布尔值：true 和 false 分别被转换为字符串 "true" 和 "false"。

其他类型：

字符串：保持不变。

数组：数组元素被连接成一个字符串，用逗号分隔。

对象：默认转换为 "[object Object]"，除非对象定义了自定义的 toString 方法。

日期：Date 对象被转换为当前日期时间的字符串表示形式。

函数：函数被转换为其源代码的字符串表示形式。

3. 特殊场景下的转换

比较操作符

在松散比较 (==) 中，如果一侧是字符串而另一侧是数字，则字符串会被尝试转换为数字进行比较。

console.log("42" == 42); // true
console.log("42" == "42.0"); // true
console.log("hello" == 42); // false, 因为 "hello" 转换为 NaN

在严格比较 (===) 中，不仅比较值还要比较类型，因此不同类型的值即使数值相同也不会相等。

console.log("42" === 42); // false

加法运算符

如果加法运算符的一侧是字符串，则另一侧会被转换为字符串并进行字符串连接。

console.log("The answer is " + 42); // 输出: "The answer is 42"

如果两侧都是数值或者可以被转换成数值，则执行数值相加。

console.log("5" + 7); // 输出: "57" （因为 "5" 是字符串，所以7也被转换为字符串）

其他运算符

减法、乘法、除法等算术运算符总是将操作数转换为数值后再进行计算。

console.log("5" - 2); // 输出: 3
console.log("10" * "2"); // 输出: 20

4. 格式化输出

有时我们希望将数值或其他类型格式化为特定格式的字符串：

console.log((42).toString());           // "42"
console.log((42).toString(16));         // "2a" (十六进制)
console.log(new Date().toString());     // 当前日期时间的字符串表示
console.log(JSON.stringify({name: "Alice"})); // '{"name":"Alice"}'

3.boolean

1. 隐式转换

转换为数值（Number）

true 被转换为 1。

false 被转换为 0。

console.log(Number(true));  // 1
console.log(Number(false)); // 0

转换为字符串（String）

true 被转换为字符串 "true"。

false 被转换为字符串 "false"。

console.log(String(true));  // "true"
console.log(String(false)); // "false"

转换为对象（Object）

使用 Boolean 构造函数创建一个新的 Boolean 对象。

let boolObj = new Boolean(true);
console.log(typeof boolObj); // "object"

2. 显式转换

使用构造函数或全局方法

console.log(Boolean());                  // false 默认值为false
console.log(Boolean(false));             // false 布尔值 false 转换为 false
console.log(Boolean(true));              // true 布尔值 true 转换为 true
console.log(Boolean(undefined));         // false undefined 被视为假值
console.log(Boolean(null));              // false null 被视为假值
console.log(Boolean(0));                 // false 数字 0 被视为假值
console.log(Boolean(''));                // false 空字符串被视为假值
console.log(Boolean(NaN), 'NaN');        // false, 'NaN' NaN 被视为假值
console.log(Boolean(-0), '-0');          // false, '-0' -0 被视为假值
console.log(Boolean(+0), '+0');          // false, '+0' +0 被视为假值

// 追加更多类型的转换示例
console.log(Boolean(42));                // true 非零数字被视为真值
console.log(Boolean("hello"));           // true 非空字符串被视为真值
console.log(Boolean({}));                // true 非空对象被视为真值
console.log(Boolean([]));                // true 非空数组被视为真值
console.log(Boolean("0"));               // true 字符串 "0" 被视为真值（非空字符串）
console.log(Boolean("false"));           // true 字符串 "false" 被视为真值（非空字符串）

解释

默认值：当 Boolean() 没有提供参数时，默认返回 false。

布尔值：

false 和 true 分别保持其原始的布尔值。

特殊值：

undefined, null, 0, '', NaN, -0, +0 都被视为假值 (falsy)。

其他类型：

非零数字、非空字符串、非空对象和非空数组都被视为真值 (truthy)。

注意，即使是字符串 "0" 和 "false"，因为它们是非空字符串，所以也被视为真值。

3. 特殊场景下的转换

比较操作符

在松散比较 (==) 中，JavaScript 会在比较之前尝试进行类型转换。例如，false == 0 返回 true，因为 false 被转换为 0。

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

在严格比较 (===) 中，不仅比较值还要比较类型，因此不同类型的值即使数值相同也不会相等。

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

加法运算符

如果加法运算符的一侧是布尔值，则另一侧会被转换为数值并进行数值相加。

console.log(true + 1);       // 2
console.log(false + 5);      // 5

如果一侧是字符串，则布尔值会被转换为字符串并进行字符串连接。

console.log(true + "");      // "true"
console.log(false + "hello"); // "falsehello"

4. 其他运算符

减法、乘法、除法等算术运算符总是将操作数转换为数值后再进行计算。

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

4.bigint

1. 隐式转换

转换为布尔值（Boolean）

BigInt 类型的任何非零值都被视为真值（truthy），而 0n（即 BigInt(0)）被视为假值（falsy）。

console.log(Boolean(BigInt(0))); // false
console.log(Boolean(BigInt(123))); // true

转换为字符串（String）

BigInt 类型的值可以被转换为对应的字符串表示形式。

console.log(String(BigInt(1234567890123456789012345678901234567890))); 
// "1234567890123456789012345678901234567890"

转换为对象（Object）

使用 BigInt 构造函数创建一个新的 BigInt 对象。

let bigIntObj = new BigInt(123);
console.log(typeof bigIntObj); // "object"

2. 显式转换

使用构造函数或全局方法

可以使用 BigInt(), Number(), 和 String() 构造函数或者它们对应的全局方法来进行显式的类型转换。

console.log(Number(BigInt(123))); // 123 如果数值在安全整数范围内则转换成功，否则抛出错误
console.log(String(BigInt(123))); // "123"
console.log(BigInt(123));         // 123n
console.log(BigInt("123"));       // 123n

3. 特殊场景下的转换

数值与 BigInt 的混合运算

BigInt 不能直接与普通 number 类型进行算术运算，除非你明确地将它们都转换为同一种类型。如果尝试这样做，JavaScript 会抛出一个 TypeError。

Javascript 代码解读复制代码

try {
    console.log(BigInt(123) + 456); // 抛出 TypeError
} catch (e) {
    console.log(e.name, e.message); // TypeError: Cannot mix BigInt and other types
}

// 正确的做法是确保所有操作数都是 BigInt 类型
console.log(BigInt(123) + BigInt(456)); // 579n

比较操作符

在比较操作中，BigInt 和 number 类型的值不会自动转换为同一类型进行比较。因此，即使数值相同，它们也不会相等。

console.log(BigInt(123) === 123); // false
console.log(BigInt(123) == 123);  // false

4. 显示转换示例

以下是具体的显示转换示例代码，附带详细的注释：

console.log(Boolean(BigInt(0))); // false 因为 0n 是假值
console.log(Boolean(BigInt(123))); // true 非零 BigInt 是真值

console.log(String(BigInt(1234567890123456789012345678901234567890))); 
// "1234567890123456789012345678901234567890" BigInt 被转换为字符串

console.log(Number(BigInt(123))); // 123 如果数值在安全整数范围内则转换成功
try {
    console.log(Number(BigInt(12345678901234567890))); // 抛出 RangeError
} catch (e) {
    console.log(e.name, e.message); // RangeError: Cannot convert a BigInt value to a number
}

console.log(BigInt(123), typeof BigInt(123)); // 123n, 'bigint' 将数字转换为 BigInt

console.log(BigInt("123"), typeof BigInt("123")); // 123n, 'bigint' 将字符串转换为 BigInt
try {
    console.log(BigInt("123a")); // 抛出 SyntaxError
} catch (e) {
    console.log(e.name, e.message); // SyntaxError: Invalid BigInt literal
}

5. 注意事项

范围限制：BigInt 支持任意大小的整数，但 Number 类型有其安全整数范围（-2^53 到 2^53 - 1）。当 BigInt 超出这个范围时，将其转换为 Number 会导致错误。

性能影响：由于 BigInt 支持更大的数值范围，它的运算速度可能比普通的 number 类型慢，尤其是在频繁进行数学运算的情况下。

浏览器支持：BigInt 是 ES2020 引入的新特性，确保你的目标环境支持这一特性。对于不支持 BigInt 的旧版浏览器，需要考虑兼容性解决方案。

5.symbol

1. 隐式转换

转换为布尔值（Boolean）

所有 Symbol 类型的值都被视为真值（truthy），因为它们总是表示一个存在的符号。

console.log(Boolean(Symbol())); // true
console.log(Boolean(Symbol('description'))); // true

转换为数值（Number）

Symbol 类型不能被直接转换为数值，尝试这样做会导致抛出 TypeError。

try {
    console.log(Number(Symbol())); // 抛出 TypeError
} catch (e) {
    console.log(e.name, e.message); // TypeError: Cannot convert a Symbol value to a number
}

转换为字符串（String）

Symbol 类型可以被显式地转换为字符串，但隐式转换时会抛出错误。使用 String() 或者模板字符串可以安全地将 Symbol 转换为字符串。

console.log(String(Symbol('foo'))); // "Symbol(foo)"
console.log(`${Symbol('bar')}`);    // "Symbol(bar)"

// 隐式转换会抛出错误
try {
    console.log(Symbol('baz') + ''); // 抛出 TypeError
} catch (e) {
    console.log(e.name, e.message); // TypeError: Cannot convert a Symbol value to a string
}

2. 显式转换

使用构造函数或全局方法

可以使用 String() 构造函数或者模板字符串来进行显式的类型转换。

console.log(String(Symbol('key'))); // "Symbol(key)"
console.log(`${Symbol('anotherKey')}`); // "Symbol(anotherKey)"

Symbol 本身没有提供直接转换为其他类型的内置方法。

3. 特殊场景下的转换

比较操作符

Symbol 类型的值是唯一的，即使两个 Symbol 使用相同的描述创建，它们也不相等。

let sym1 = Symbol('key');
let sym2 = Symbol('key');
console.log(sym1 === sym2); // false

// 即使是用同一个 Symbol.for() 创建的 symbol 也会相等
let sym3 = Symbol.for('sharedKey');
let sym4 = Symbol.for('sharedKey');
console.log(sym3 === sym4); // true

对象属性键

Symbol 主要用于作为对象属性的键，确保属性名不会发生冲突。它们不会被枚举，并且在对象序列化（如 JSON.stringify）时会被忽略。

let obj = {};
let sym = Symbol('unique');

obj[sym] = 'value';
console.log(obj[sym]); // "value"

for (let key in obj) {
    console.log(key); // 不输出任何内容，因为 Symbol 属性不会被枚举
}

console.log(JSON.stringify(obj)); // "{}"，Symbol 属性被忽略

4. 显示转换示例

以下是具体的显示转换示例代码，附带详细的注释：

console.log(Boolean(Symbol())); // true 所有 Symbol 类型的值都是真值

console.log(String(Symbol('foo')), typeof String(Symbol('foo'))); 
// "Symbol(foo)", "string" 显式转换为字符串

console.log(`${Symbol('bar')}`, typeof `${Symbol('bar')}`); 
// "Symbol(bar)", "string" 使用模板字符串转换为字符串

try {
    console.log(Number(Symbol())); // 抛出 TypeError
} catch (e) {
    console.log(e.name, e.message); 
    // TypeError: Cannot convert a Symbol value to a number
}

try {
    console.log(Symbol('baz') + ''); // 抛出 TypeError
} catch (e) {
    console.log(e.name, e.message); 
    // TypeError: Cannot convert a Symbol value to a string
}

// Symbol 作为对象属性键
let myObj = {};
let uniqueSym = Symbol('uniqueKey');
myObj[uniqueSym] = 'uniqueValue';
console.log(myObj[uniqueSym]); // "uniqueValue"

6.undefined 和 null

undefined和null没有构造函数，但是几个例子就能看懂这两者的转换

// 转换为布尔值
console.log(!!undefined); // false undefined 是假值
console.log(!!null);      // false null 是假值

// 转换为数值
console.log(+undefined);  // NaN undefined 转换为 NaN
console.log(+null);       // 0 null 转换为 0

// 转换为字符串
console.log(String(undefined)); // "undefined" undefined 转换为 "undefined"
console.log(String(null));      // "null" null 转换为 "null"

// 使用隐式转换到字符串
console.log("" + undefined);    // "undefined" 字符串连接
console.log("" + null);         // "null" 字符串连接

// 松散比较
console.log(undefined == null); // true undefined 和 null 在松散比较中相等

// 严格比较
console.log(undefined === null); // false undefined 和 null 在严格比较中不相等

// 加法运算符
console.log(undefined + 1);     // NaN undefined 转换为 NaN
console.log(null + 1);          // 1 null 转换为 0

console.log(undefined + "");    // "undefined" 字符串连接
console.log(null + "");         // "null" 字符串连接

// 减法、乘法、除法等算术运算符
console.log(undefined - 1);     // NaN undefined 转换为 NaN
console.log(null - 1);          // -1 null 转换为 0

console.log(undefined * 2);     // NaN undefined 转换为 NaN
console.log(null * 2);          // 0 null 转换为 0

console.log(undefined / 2);     // NaN undefined 转换为 NaN
console.log(null / 2);          // 0 null 转换为 0

解释

转换为布尔值：使用双重否定 !! 可以将任何值转换为布尔值。

转换为数值：使用一元加号 + 可以将任何值转换为数值。

转换为字符串：直接调用 String() 或使用隐式转换（如与空字符串相加）可以将任何值转换为字符串。

松散比较 (==) 和严格比较 (===) ：展示了 undefined 和 null 在不同比较操作中的行为。

加法运算符：展示了当一侧是 undefined 或 null 时的行为，以及它们与字符串和数值的交互。

其他算术运算符：展示了减法、乘法和除法在处理 undefined 和 null 时的行为。

7.object

1. 隐式转换

转换为布尔值（Boolean）

空对象 {} 和非空对象都被视为真值（truthy）。

console.log(!!{}); // true
console.log(!!{key: "value"}); // true

转换为数值（Number）

对象被转换为数值时会抛出 TypeError，除非该对象有自定义的 valueOf() 或 toString() 方法返回一个可转换为数值的值。

try {
    console.log(Number({})); // 抛出 TypeError
} catch (e) {
    console.log(e.name, e.message); // TypeError: Cannot convert object to primitive value
}

// 如果对象有自定义的 valueOf() 或 toString() 方法
let obj = {
    valueOf: function() { return 42; }
};
console.log(Number(obj)); // 42

转换为字符串（String）

默认情况下，对象被转换为字符串 [object Object]。如果对象有自定义的 toString() 方法，则使用该方法的结果。

console.log(String({})); // "[object Object]"
console.log(String({key: "value"})); // "[object Object]"

// 自定义 toString 方法
let objWithToString = {
    toString: function() { return "custom string"; }
};
console.log(String(objWithToString)); // "custom string"

2. 显式转换

使用全局方法

可以使用 Boolean(), Number(), 和 String() 全局方法来进行显式的类型转换。

console.log(Boolean({})); // true
console.log(Boolean({key: "value"})); // true

try {
    console.log(Number({})); // 抛出 TypeError
} catch (e) {
    console.log(e.name, e.message); // TypeError: Cannot convert object to primitive value
}

console.log(String({})); // "[object Object]"
console.log(String({key: "value"})); // "[object Object]"

3. 特殊场景下的转换

比较操作符

在松散比较 (==) 中，如果一侧是对象而另一侧是其他类型，则对象会被尝试转换为对应的原始类型进行比较。

console.log({} == {}); // false 因为两个不同的对象引用不同
console.log({a: 1} == {a: 1}); // false 同理

// 如果对象有自定义的 valueOf() 或 toString() 方法
let objWithValueOf = {
    valueOf: function() { return 42; }
};
console.log(objWithValueOf == 42); // true

在严格比较 (===) 中，只有当两侧都是同一个对象引用时才会相等。

let obj = {};
console.log(obj === obj); // true
console.log(obj === {}); // false 因为是不同的对象实例

加法运算符

如果加法运算符的一侧是对象，则另一侧会被转换为字符串并进行字符串连接。

console.log({} + ""); // "[object Object]"
console.log({a: 1} + ""); // "[object Object]"

其他算术运算符

减法、乘法、除法等算术运算符总是将对象转换为数值后再进行计算。如果转换失败，结果为 NaN。

try {
    console.log({} - 1); // NaN
    console.log({} * 2); // NaN
    console.log({} / 2); // NaN
} catch (e) {
    console.log(e.name, e.message);
}

4. 显示转换示例

以下是具体的显示转换示例代码，附带详细的注释：

// 转换为布尔值
console.log(!!{}); // true 空对象是真值
console.log(!!{key: "value"}); // true 非空对象是真值

// 转换为数值
try {
    console.log(+{}); // 抛出 TypeError
} catch (e) {
    console.log(e.name, e.message); // TypeError: Cannot convert object to primitive value
}

let objWithValueOf = {
    valueOf: function() { return 42; }
};
console.log(+objWithValueOf); // 42

// 转换为字符串
console.log(String({})); // "[object Object]"
console.log("" + {}); // "[object Object]" 字符串连接

let objWithToString = {
    toString: function() { return "custom string"; }
};
console.log(String(objWithToString)); // "custom string"

// 松散比较
console.log({} == {}); // false 不同的对象实例不相等
console.log({a: 1} == {a: 1}); // false 不同的对象实例不相等

let objWithValueOfForLoose = {
    valueOf: function() { return 42; }
};
console.log(objWithValueOfForLoose == 42); // true

// 严格比较
let objForStrict = {};
console.log(objForStrict === objForStrict); // true 相同的对象引用相等
console.log(objForStrict === {}); // false 不同的对象实例不相等

// 加法运算符
console.log({} + ""); // "[object Object]"
console.log({a: 1} + ""); // "[object Object]"

// 其他算术运算符
try {
    console.log({} - 1); // NaN
    console.log({} * 2); // NaN
    console.log({} / 2); // NaN
} catch (e) {
    console.log(e.name, e.message);
}

结尾

通过本文的详细探讨，我们深入了解了 JavaScript 中 object 复杂数据类型与其他基本数据类型之间的转换规则。无论是隐式转换还是显式转换，理解这些规则对于编写健壮且可预测的代码至关重要。掌握不同类型之间的相互转换不仅可以帮助你避免常见的错误，还能让你更好地理解和优化代码的行为。

在日常开发中，合理利用对象的自定义方法（如 valueOf() 和 toString()），可以实现更加灵活和强大的功能。同时，在处理对象与其他类型的比较和运算时，务必谨慎对待松散比较和严格比较的区别，以确保程序逻辑的正确性。

希望本文的内容能够为你提供有价值的参考，并为你的编程实践带来启发。无论你是正在解决复杂的类型转换问题，还是希望更深入地理解 JavaScript 的工作原理，都愿这篇文章能成为你可靠的指南。

如果你对 JavaScript 类型转换有更多疑问或需要进一步的帮助，请随时查阅相关文档或继续深入研究。编程的世界充满无限可能，不断学习和探索将使你成为一名更加出色的开发者。