每日一知识：JavaScript 中的类型转换机制以及== 和 ===区别

JavaScript 中的类型转换机制

JS中有七种简单数据类型：undefined、null、boolean、string、number、bigInt、symbol，以及引用类型：object

但是我们在声明的时候只有一种数据类型，只有到运行期间才会确定当前类型

let x = y ? 1 : a;
​
//上面代码中，x的值在编译阶段是无法获取的，只有等到程序运行时才能知道

创建变量时的数据类型是不确定的，但是各种运算符对数据类型是有要求的，如果运算子的类型不符合预期，就会触发类型转换机制

常见的类型转换有：

• 强制转换(显示)
• 自动转换(隐式)

一.显示转换

显示转换，即我们很清楚可以看到这里发生了类型的转变，常见的方法有：

• Number()
• parseInt()
• String()
• Boolean()

Number()

将任意类型的值转化为数值

Number转换的时候是很严格的，只要有一个字符无法转成数值，整个字符串就会被转为NaN

类型转换规则：

Number(324) // 324
​
// 字符串：如果可以被解析为数值，则转换为相应的数值
Number('324') // 324
​
// 字符串：如果不可以被解析为数值，返回 NaN
Number('324abc') // NaN
​
// 空字符串转为0
Number('') // 0
​
// 布尔值：true 转成 1，false 转成 0
Number(true) // 1
Number(false) // 0
​
// undefined：转成 NaN
Number(undefined) // NaN
​
// null：转成0
Number(null) // 0
​
// 对象：通常转换成NaN(除了只包含单个数值的数组)
Number({a: 1}) // NaN
Number([1, 2, 3]) // NaN
Number([5]) // 5

parseInt()

parseInt相比Number，就没那么严格了，parseInt函数逐个解析字符，遇到不能转换的字符就停下来

parseInt('32a3') //32

String()

可以将任意类型的值转化成字符串

给出转换规则图：

// 数值：转为相应的字符串
String(1) // "1"
​
//字符串：转换后还是原来的值
String("a") // "a"
​
//布尔值：true转为字符串"true"，false转为字符串"false"
String(true) // "true"
​
//undefined：转为字符串"undefined"
String(undefined) // "undefined"
​
//null：转为字符串"null"
String(null) // "null"
​
//对象
String({a: 1}) // "[object Object]"
String([1, 2, 3]) // "1,2,3"

Boolean()

可以将任意类型的值转为布尔值，转换规则如下：

Boolean(undefined) // false
Boolean(null) // false
Boolean(0) // false
Boolean(NaN) // false
Boolean('') // false
Boolean({}) // true
Boolean([]) // true
Boolean(new Boolean(false)) // true

二.隐式转换

何时发生隐式转换？

可以归纳为两种情况发生隐式转换的场景：

• 比较运算（==、!=、>、<),if,while等需要布尔值的地方
• 算数运算（+、-、*、/、%）

除了上面的场景，还要求运算符两边的操作数不是同一类型

自动转换为布尔值

在需要布尔值的地方，就会将非布尔值的参数自动转为布尔值，系统内部会调用Boolean函数

记住：

• undefined
• null
• false
• +0
• -0
• NaN
• 空字符串

除了以上会转为false，其余都转换为true

自动转换成字符串

遇到预期为字符串的地方，就会将非字符串的值自动转为字符串

具体的转换规则是：先将复合类型的值转为原始类型的值，再将原始类型的值转为字符串

常发生在+运算中，一旦存在字符串，则会进行字符串拼接操作

'5' + 1 // '51'
'5' + true // "5true"
'5' + false // "5false"
'5' + {} // "5[object Object]"
'5' + [] // "5"
'5' + function (){} // "5function (){}"
'5' + undefined // "5undefined"
'5' + null // "5null"

自动转换成数值

除了+有可能把运算子转为字符串，其他运算符都会把运算子自动转成数值

'5' - '2' // 3
'5' * '2' // 10
true - 1  // 0
false - 1 // -1
'1' - 1   // 0
'5' * []    // 0
false / '5' // 0
'abc' - 1   // NaN
null + 1 // 1
undefined + 1 // NaN

null转为数值时，值为0 。undefined转为数值时，值为NaN

== 和 ===区别，分别在什么情况使用

==运算符

等于操作符用两个等于号（ == ）表示，如果操作数相等，则会返回 true

JavaScript中存在隐式转换。等于操作符（==）在比较中会先进行类型转换，再确定操作数是否相等

遵循以下规则：

如果任一操作数是布尔值，则将其转换为数值再比较是否相等

let result1 = (true == 1); // true

如果一个操作数是字符串，另一个操作数是数值，则尝试将字符串转换为数值，再比较是否相等

let result1 = ("55" == 55); // true

如果一个操作数是对象，另一个操作数不是，则调用对象的 valueOf()方法取得其原始值，进行比较，如果得到的还是对象，则再调用toString()方法，得到字符串形式，再进行比较。

let obj = {valueOf:function(){return 1}}
let result1 = (obj == 1); // true

null和undefined相等 undefined和null只有与自身比较，或者互相比较时，才会返回true；与其他类型的值比较时，结果都为false。

undefined == undefined // true
null == null // true
undefined == null // true
​
false == null // false
false == undefined // false
​
0 == null // false
0 == undefined // false

如果有任一操作数是 NaN ，则相等操作符返回 false（NaN）包括自己

let result1 = (NaN == NaN ); // false

如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象，则相等操作符返回true

let obj1 = {name:"xxx"}
let obj2 = {name:"xxx"}
let result1 = (obj1 == obj2 ); // false

下面进一步做个小结：

• 两个都为简单数据类型，字符串和布尔值都会转换为数值，再进行比较
• 简单数据类型于引用数据类型比较，对象转化为原始类型的值，再比较
• 两个都为引用类型，比较地址
• null == undefined
• 存在NaN 则返回false 包括自己

===运算符

全等操作符由 3 个等于号（ === ）表示，只有两个操作数在不转换的前提下相等才返回 true。即类型相同，值也需相同

let result1 = ("55" === 55); // false，不相等，因为数据类型不同
let result2 = (55 === 55); // true，相等，因为数据类型相同值也相同

undefined 和 null 与自身严格相等

let result1 = (null === null)  //true
let result2 = (undefined === undefined)  //true

NaN === NaN fasle

两个复合类型（对象、数组、函数）的数据比较时，不是比较它们的值是否相等，而是比较它们是否指向同一个地址。

注意，对于两个对象的比较，严格相等运算符比较的是地址，而大于或小于运算符比较的是值。

var obj1 = {};
var obj2 = {};
​
obj1 > obj2 // false
obj1 < obj2 // false
obj1 === obj2 // false

区别

• 相等操作符（==）会做类型转换，再进行值的比较，全等运算符不会做类型转换
• null 和 undefined 比较，相等操作符（==）为true，全等为false

小结

相等运算符隐藏的类型转换，会带来一些违反直觉的结果

'' == '0' // false
0 == '' // true
0 == '0' // true
​
false == 'false' // false
false == '0' // true
​
false == undefined // false
false == null // false
null == undefined // true
​
' \t\r\n' == 0 // true

但在比较null的情况的时候，我们一般使用相等操作符==，因为null == undefined，使用相等操作符（==）的写法明显更加简洁了

const obj = {};
​
if(obj.x == null){
  console.log("1");  //执行
}
​
//等同于
if(obj.x === null || obj.x === undefined) {
    ...
}

所以，除了在比较对象属性为null或undefined时候，使用相等操作符（），其他情况建议一律使用全等操作符（=）