本文详解 JavaScript 中的隐式类型转换机制，涵盖数学运算符、加法拼接、逻辑判断及 == 比较中的具体转换规则。重点解析 ToPrimitive 算法如何调用 valueOf 和 toString，以及空对象与空数组的特殊处理逻辑，帮助开发者避免常见的类型陷阱。
引言
JavaScript在执行运算时，若操作数类型不一致，编译器会自动执行数据类型转换以完成计算，此机制称为隐式转换。
数学运算符的类型转换逻辑
减法、乘法与除法
对非 Number 类型应用数学运算符（-、* 或 /）时，系统会先将非 Number 类型转换为 Number 类型，随后执行计算。具体示例如下：
2 - true // 结果为 1，首先把 true 转换为数字 1，然后执行 2 - 1
2 - null // 结果为 0，首先把 null 转换为数字 0，然后执行 2 - 0
2 - undefined // 结果为 NaN，因为 undefined 被转换为 NaN，然后执行 2 - NaN
2 * '5' // 结果为 10，'5' 首先会变成数字 5, 然后执行 2 * 5
需留意：算术运算中若存在 undefined，结果即为 NaN；而 null 在算术运算中会隐式转换为数值 0 参与计算。
加法运算
加法之所以特殊，是因为 js 中 + 兼具字符串拼接功能。
加法运算遵循以下 3 条规则，按优先级从高到低排列：
若一侧为 String 类型，则识别为字符串拼接，并优先将另一侧转换为字符串类型。
若一侧为 Number 类型，另一侧为原始类型，则将原始类型转换为 Number 类型。
若一侧为 Number 类型，另一侧为引用类型，则将引用类型和 Number 类型转换为字符串后进行拼接。
具体示例如下：
123 + '123' // 246 (规则1)
123 + null // 123 (规则2)
123 + true // 124 (规则2)
123 + undefined // NaN (规则2)
123 + {} // 123[object Object] (规则3)
逻辑语句中的类型转换
单一变量场景
若仅涉及单一变量，会先将其转换为 Boolean 值。仅 null、undefined、''、NaN、0、 false 会被转换为 false，其余情况均转换为 true，例如 {} 和 [] 等。示例如下：
if (null) {
console.log('111')
} else {
console.log('222')
}
// 输出 222
使用 == 进行比较
使用 == 进行比较，其规则如下：
NaN 与任何类型（含自身）比较均返回 false。
Boolean 与任何类型比较时，Boolean 首先被转换为 Number 类型。
String 与 Number 比较时，先将 String 类型转换为 Number 类型。
null == undefined 比较结果为 true，除此之外，null、undefined 与其他任何类型的比较结果均为 false。
原始类型 与 引用类型 比较时，引用类型会依据 ToPrimitive 规则转换为原始类型（ToPrimitive 详见下文）。
具体示例如下：
NaN == NaN // false (规则1)
// (规则2)
true == 1 // true
true == '1' // true
true == '2' // false
true == ['1'] // true, 先把 true 变成 1， ['1'] 拆箱成 '1', 再参考(规则3)
true == ['2'] // false, 同上
// (规则3)
123 == '123' // true
'' == 0 // true
// (规则4)
null == undefined // true
null == '' // false
null == 0 // false
null == false // false
undefined == '' // false
undefined == 0 // false
undefined == false // false
// (规则5)
'[object Object]' == {} // true, 字符串和对象比较，对象通过 toString 得到一个基本类型值
'1,2,3' == [1,2,3] // true, 同上，[1,2,3] 通过 toString 得到一个基本类型值
ToPrimitive 机制
ToPrimitive 规则会尝试调用对象的 valueOf 和 toString 方法，旨在将参数转换为原始类型。
当对象类型需转为原始类型时，系统先查找对象的 valueOf 方法；若 valueOf 方法返回原始类型的值，则 ToPrimitive 的结果即为该值；若 valueOf 不存在或 valueOf 方法返回的不是原始类型的值，则会尝试调用对象的 toString 方法，即遵循对象的 ToString 规则，并使用 toString 的返回值作为 ToPrimitive 的结果。
具体示例如下：
let str = new String(1) // 通过 new String 创建了一个对象
console.log(typeof str) // object
console.log(str.valueOf()) // "1"
console.log(typeof str.valueOf()) // string
const obj = {
valueOf() {
return 1
},
toString() {
return 2
}
}
console.log(Number(obj)) // 1
注意：若 valueOf 和 toString 均未返回原始类型的值，系统将抛出异常。
具体示例如下：
const obj = {
valueOf() {
return []
},
toString() {
return {}
}
}
console.log(Number(obj)) // TypeError: Cannot convert object to primitive value
特殊情况：
String({}) // [object Object]
Number([]) // 0
String({}) 空对象会先调用 valueOf，但返回的是对象本身 {}，并非原始类型，因此会继续调用 toString，得到 [object Object] 和 String([object Object])，故转换后的结果为 [object Object]。
Number([]) 空数组会先调用 valueOf，但返回的是数组本身 []，并非原始类型，因此会继续调用 toString，得到 ''，这相当于执行 Number('')，故转换后的结果为 0。
以上即为 JavaScript 隐式类型转换规则的完整解析，更多 JavaScript 隐式类型转换相关内容，敬请关注本站其他相关文章！