JavaScript类型转换规则有哪些？类型系统深度解析

JavaScript的类型系统包含原始类型和对象类型两大类，原始类型有Undefined、Null、Boolean、Number、String、Symbol、BigInt七种，对象类型则是除了原始类型之外的所有类型。类型转换是不同类型值之间进行运算时必然会发生的操作，分为显式转换和隐式转换两种形式。

显式类型转换

显式类型转换是开发者主动调用转换方法将值转为目标类型，转换逻辑清晰可控，常见的显式转换场景有以下几种。

转为Number类型

常用的转换方法有Number()、parseInt()、parseFloat()，三者的转换规则存在区别。

// Number()转换规则
console.log(Number(undefined)); // NaN
console.log(Number(null)); // 0
console.log(Number(true)); // 1
console.log(Number(false)); // 0
console.log(Number("123")); // 123
console.log(Number("123a")); // NaN
console.log(Number("")); // 0

// parseInt转换规则，会忽略字符串前面的空格，遇到非数字字符停止
console.log(parseInt("123")); // 123
console.log(parseInt("123a45")); // 123
console.log(parseInt("a123")); // NaN
console.log(parseInt("   123")); // 123

// parseFloat转换规则，支持小数转换
console.log(parseFloat("123.45")); // 123.45
console.log(parseFloat("123.45.67")); // 123.45

转为String类型

常用转换方法有String()、toString()，toString()不能直接用于undefined和null，否则会报错。

// String()转换规则
console.log(String(123)); // "123"
console.log(String(true)); // "true"
console.log(String(undefined)); // "undefined"
console.log(String(null)); // "null"

// toString()转换规则
const num = 123;
console.log(num.toString()); // "123"
const bool = false;
console.log(bool.toString()); // "false"
// undefined.toString(); // 报错
// null.toString(); // 报错

转为Boolean类型

使用Boolean()方法转换，只有几个固定的假值会转为false，其余都为true。

// 转为false的情况
console.log(Boolean(undefined)); // false
console.log(Boolean(null)); // false
console.log(Boolean(false)); // false
console.log(Boolean(0)); // false
console.log(Boolean(NaN)); // false
console.log(Boolean("")); // false

// 其余情况都转为true
console.log(Boolean(1)); // true
console.log(Boolean("abc")); // true
console.log(Boolean([])); // true
console.log(Boolean({})); // true

隐式类型转换

隐式类型转换是JavaScript在运行过程中自动触发的转换，通常发生在比较运算、算术运算等场景中，规则相对复杂。

算术运算中的隐式转换

加法运算符+比较特殊，当有一侧是字符串时，会将另一侧转为字符串进行拼接，其余算术运算符都会将操作数转为Number类型再计算。

// 加法运算符场景
console.log(1 + "2"); // "12"，字符串拼接
console.log("1" + 2); // "12"
console.log(true + 1); // 2，true转为1
console.log(null + 1); // 1，null转为0
console.log(undefined + 1); // NaN，undefined转为NaN

// 其余算术运算符场景
console.log("2" - 1); // 1，"2"转为2
console.log("2" * "3"); // 6，都转为Number
console.log("2" / "1"); // 2
console.log("a" - 1); // NaN

比较运算中的隐式转换

比较运算符分为宽松相等==和严格相等===，严格相等不会进行类型转换，宽松相等会触发隐式转换，转换规则如下：

• 如果两侧类型相同，直接比较值
• 如果一侧是null，另一侧是undefined，返回true
• 如果一侧是Number，另一侧是String，将String转为Number再比较
• 如果一侧是Boolean，将Boolean转为Number再比较
• 如果一侧是对象，另一侧是原始类型，将对象转为原始类型再比较

console.log(null == undefined); // true
console.log(1 == "1"); // true，"1"转为1
console.log(true == 1); // true，true转为1
console.log([] == 0); // true，[]转为""再转为0
console.log([] == false); // true，[]转为""，false转为0，""转为0
console.log({} == "[object Object]"); // true，{}转为字符串"[object Object]"

逻辑运算中的隐式转换

逻辑与&&、逻辑或||、逻辑非!都会触发Boolean隐式转换，逻辑非会直接返回布尔值，逻辑与和逻辑或会返回原值。

console.log(!0); // true，0转为false再取反
console.log(!"abc"); // false，"abc"转为true再取反
console.log(1 && 2); // 2，1为truthy，返回第二个值
console.log(0 && 2); // 0，0为falsy，返回第一个值
console.log(1 || 2); // 1，1为truthy，返回第一个值
console.log(0 || 2); // 2，0为falsy，返回第二个值

常见类型转换误区

很多开发者容易混淆[] == ![]的结果，分析过程如下：首先![]会将[]转为Boolean，[]是truthy，所以![]结果为false；然后==比较时，右侧false转为0，左侧[]转为""再转为0，所以最终结果为true。

console.log([] == ![]); // true
// 分步解析
console.log(![]); // false
console.log(Number(false)); // 0
console.log(Number([])); // 0
console.log(0 == 0); // true

另外需要注意NaN的比较特性，NaN不等于任何值，包括它自己，判断一个值是否为NaN需要使用isNaN()或者Number.isNaN()方法。

console.log(NaN == NaN); // false
console.log(NaN === NaN); // false
console.log(isNaN(NaN)); // true
console.log(Number.isNaN(NaN)); // true

JavaScript类型转换类型系统隐式转换显式转换修改时间：2026-06-26 23:15:52