'2'>'10'==true? JS是如何进行隐式类型转换的?

时间:2023-12-23 19:48:43

前言

'2'>'10'返回的true,可能很多人都不是很能理解吧? 在js中,当运算符在运算时,如果两边数据不统一,CPU就无法计算,这时我们编译器会自动将运算符两边的数据做一个数据类型转换,转成一样的数据类型再计算。 这种无需程序员手动转换,而由编译器自动转换的方式就称为隐式转换。

如果这篇文章有帮助到你,️关注+点赞️鼓励一下作者,文章公众号首发~

想要知道'2'>'10'为什么是true,我们得先来了解一下JavaScript的隐式类型转换规则。

隐式类型转换规则

1. == 操作符的强制类型转换规则?

  • 字符串和数字之间的相等比较,将字符串转换为数字之后再进行比较。
  • 其他类型和布尔类型之间的相等比较,先将布尔值转换为数字后,再应用其他规则进行比较。
  • null 和 undefined 之间的相等比较,结果为真。其他值和它们进行比较都返回假值。
  • 对象和非对象之间的相等比较,对象先调用 ToPrimitive 抽象操作后,再进行比较。
  • 如果一个操作值为 NaN ,则相等比较返回 false( NaN 本身也不等于 NaN )。
  • 如果两个操作值都是对象,则比较它们是不是指向同一个对象。如果两个操作数都指向同一个对象,则相等操作符返回true,否则,返回 false。

2.递增递减操作符(前置与后置)、一元正负操作符

这些操作符适用于任何数据类型的值,针对不同类型的值,该操作符遵循以下规则(经过对比发现,其规则与Number()规则基本相同):

  • 如果是包含有效数字字符的字符串,先将其转换为数字值(转换规则同Number()),在执行加减1的操作,字符串变量变为数值变量。
  • 如果是不包含有效数字字符的字符串,将变量的值设置为NaN,字符串变量变成数值变量。
  • 如果是布尔值false,先将其转换为0再执行加减1的操作,布尔值变量编程数值变量。
  • 如果是布尔值true,先将其转换为1再执行加减1的操作,布尔值变量变成数值变量。
  • 如果是浮点数值,执行加减1的操作。
  • 如果是对象,先调用对象的valueOf()方法,然后对该返回值应用前面的规则。如果结果是NaN,则调用toString()方法后再应用前面的规则。对象变量变成数值变量。

3.加法运算操作符

加号运算操作符在Javascript也用于字符串连接符,所以加号操作符的规则分两种情况:

如果两个操作值都是数值,其规则为:

  • 如果一个操作数为NaN,则结果为NaN
  • 如果是Infinity+Infinity,结果是Infinity
  • 如果是-Infinity+(-Infinity),结果是-Infinity
  • 如果是Infinity+(-Infinity),结果是NaN
  • 如果是+0+(+0),结果为+0
  • 如果是(-0)+(-0),结果为-0
  • 如果是(+0)+(-0),结果为+0

如果有一个操作值为字符串,则:

  • 如果两个操作值都是字符串,则将它们拼接起来
  • 如果只有一个操作值为字符串,则将另外操作值转换为字符串,然后拼接起来
  • 如果一个操作数是对象、数值或者布尔值,则调用toString()方法取得字符串值,然后再应用前面的字符串规则。对于undefined和null,分别调用String()显式转换为字符串。
  • 可以看出,加法运算中,如果有一个操作值为字符串类型,则将另一个操作值转换为字符串,最后连接起来。

4. 乘除、减号运算符、取模运算符

这些操作符针对的是运算,所以他们具有共同性:如果操作值之一不是数值,则被隐式调用Number()函数进行转换。

5.逻辑操作符(!、&&、||)

逻辑非(!)操作符首先通过Boolean()函数将它的操作值转换为布尔值,然后求反。

逻辑与(&&)操作符,如果一个操作值不是布尔值时,遵循以下规则进行转换:

  • 如果第一个操作数经Boolean()转换后为true,则返回第二个操作值,否则返回第一个值(不是Boolean()转换后的值)
  • 如果有一个操作值为null,返回null
  • 如果有一个操作值为NaN,返回NaN
  • 如果有一个操作值为undefined,返回undefined

    逻辑或(||)操作符,如果一个操作值不是布尔值,遵循以下规则:
  • 如果第一个操作值经Boolean()转换后为false,则返回第二个操作值,否则返回第一个操作值(不是Boolean()转换后的值)
  • 对于undefined、null和NaN的处理规则与逻辑与(&&)相同

6.关系操作符(<, >, <=, >=)

与上述操作符一样,关系操作符的操作值也可以是任意类型的,所以使用非数值类型参与比较时也需要系统进行隐式类型转换:

  • 如果两个操作值都是数值,则进行数值比较
  • 如果两个操作值都是字符串,则比较字符串对应的字符编码值
  • 如果只有一个操作值是数值,则将另一个操作值转换为数值,进行数值比较
  • 如果一个操作数是对象,则调用valueOf()方法(如果对象没有valueOf()方法则调用toString()方法),得到的结果按照前面的规则执行比较
  • 如果一个操作值是布尔值,则将其转换为数值,再进行比较

    注:NaN是非常特殊的值,它不和任何类型的值相等,包括它自己,同时它与任何类型的值比较大小时都返回false。

7. 其他值到字符串的转换规则?

  • Null 和 Undefined 类型 ,null 转换为 “null”,undefined 转换为 “undefined”,
  • Boolean 类型,true 转换为 “true”,false 转换为 “false”。
  • Number 类型的值直接转换,不过那些极小和极大的数字会使用指数形式。
  • Symbol 类型的值直接转换,但是只允许显式强制类型转换,使用隐式强制类型转换会产生错误。
  • 对普通对象来说,除非自行定义 toString() 方法,否则会调用 toString()(Object.prototype.toString())来返回内部属性 [[Class]] 的值,如”[object Object]”。如果对象有自己的 toString() 方法,字符串化时就会调用该方法并使用其返回值。

8. 其他值到数字值的转换规则?

  • Undefined 类型的值转换为 NaN。
  • Null 类型的值转换为 0。
  • Boolean 类型的值,true 转换为 1,false 转换为 0。
  • String 类型的值转换如同使用 Number() 函数进行转换,如果包含非数字值则转换为 NaN,空字符串为 0。
  • Symbol 类型的值不能转换为数字,会报错。
  • 对象(包括数组)会首先被转换为相应的基本类型值,如果返回的是非数字的基本类型值,则再遵循以上规则将其强制转换为数字。

为了将值转换为相应的基本类型值,抽象操作 ToPrimitive 会首先(通过内部操作 DefaultValue)检查该值是否有valueOf()方法。如果有并且返回基本类型值,就使用该值进行强制类型转换。如果没有就使用 toString() 的返回值(如果存在)来进行强制类型转换。

如果 valueOf() 和 toString() 均不返回基本类型值,会产生 TypeError 错误。

9. 其他值到布尔类型的值的转换规则?

以下这些是假值: undefined、 null、 false、 +0、-0 和 NaN 、“”

假值的布尔强制类型转换结果为 false。从逻辑上说,假值列表以外的都应该是真值。

总结

  • null、undefined 是相等的,且等于自身
  • false 、 0、 '' 、 [] 是相等的
  • NaN、{} 和什么都不相等,自己跟自己都不相等
NaN == NaN  //false
NaN == undefined //false
NaN == false //false
NaN == null //false
NaN==[] //false
NaN=='' //false
NaN=={} //false false == false //true
false == undefined //false
false == null //false
false == [] //true
false == {} //false
false == '' //true undefined == undefined //true
undefined == null //true
undefined == false //false
undefined == [] //false
undefined == {} //false
undefined == '' //false null == null //true
null == NaN //false
null == [] //false
null == {} //false
null == undefined //true 0==false //true
0 == [] //true
0 == {} //false
0 == null //false
0 == undefined //false
0 == '' //true
0 == NaN //false false == [] //true
false == {} //false
false == null //false
false == undefined //false
false == '' //true
false == NaN //false []=={} //false Boolean([]) //true
Boolean({}) //true
Boolean(null) //false
Boolean(NaN) //false
Boolean(undefined) //false
Boolean('') //false
Boolean(0) //false Number(undefined) //NaN
Number({}) //NaN
Number(NaN) //NaN
Number('') //0
Number([]) //0
Number(false) //0
Number(null) //0

'2'>'10'为什么是true?

上面我们列了这么多转换的规则,那么这道题我们就可以在上面这些规则中找到答案了,首先找到关系操作符,该规则中的第二点是两个操作符都是字符串的话,则比较字符串对应的字符编码值,按我们常规思维是不是会觉得他会转为数字再比较,然后2>10,返回false,然而并不是的,是不是觉得JavaScript很坑。JavaScript中用charCodeAt()来获取字符编码

console.log('2'>'10') // true

//首先将操作符两边都转为字符编码再进行比较

'2'.charCodeAt() //50
'10'.charCodeAt() // 49 // 所以 '2'>'10' 会返回true

我们再来看几道有趣(很坑)的题

1.复杂数据类型转string

先调用valueOf()获取原始值,如果原始值不是string类型,则调用toString()转成string

console.log([1,2] == '1,2')  //true
[1,2].toString() // '1,2'
var a = {}
console.log(a.toString()) // "[object Object]"
console.log(a == "[object Object]") //true

解析:

先将左边数据类型转成string,然后两边都是string,再比较字符编码值

2.逻辑非隐式转换与关系运算符隐式转换

console.log([] == 0) // true
console.log(![] == 0) // true console.log([] == ![]) // true 是不是觉得很离谱???
console.log([] == []) //false console.log({} == !{}) //false
console.log({} == {}) // false

看到这些结果是不是很吃惊,是的我也觉得很吃惊,简直深坑。玩笑归玩笑,我们还是一起来看看到底是为什么吧!!

解析:

console.log([] == 0) // true
/*关系运算符(3)如果只有一个操作值是数值,则将另一个操作值转换为数值,进行数值比较
原理:
1.[].valueOf().toString() 得到字符串""
2.将""转为数字Number("") 得到数字0
所以 [] == 0 成立 */
console.log(![] == 0) // true
/*
原理:与上面类似,只是逻辑运算符优先级高于关系运算符,所以先执行![] 得到false
false == 0 成立
*/
console.log([] == ![])  // true
/*
上面我们知道了 []==0 ![] == 0
所以 [] == ![]
*/
console.log([] == []) //false
/*
引用数据类型数据存在堆中,栈中存储的是它们的地址,两个[]地址肯定不一样,所以是false
*/
console.log({} == !{}) //false
/*
原理:
1. {}.valueOf().toString() 得到"[object,Object]"
2. !{} == false
3. Number("[object,Object]") // NaN
Number(false) //0
4. NaN != 0 */
console.log({} == {}) // false
/*
引用数据类型数据存在堆中,栈中存储的是它们的地址,所以肯定不一样
*/

JavaScript真值表

'2'>'10'==true? JS是如何进行隐式类型转换的?

我是南玖,感谢各位的:「点赞、关注和评论」,我们下期见!