学习笔记

外观

运算符

约 1409 字大约 5 分钟

2021-03-07

===运算符判断相等的流程是怎样的?

  1. 如果两个值不是相同类型，它们不相等
  2. 如果两个值都是 null 或者都是 undefined，它们相等
  3. 如果两个值都是布尔类型 true 或者都是 false，它们相等
  4. 如果其中有一个是NaN，它们不相等
  5. 如果都是数值型并且数值相等，他们相等， -0 等于 0
  6. 如果他们都是字符串并且在相同位置包含相同的 16 位值，他它们相等；如果在长度或者内容上不等，它们不相等；两个字符串显示结果相同但是编码不同和=都认为他们不相等
  7. 如果他们指向相同对象、数组、函数，它们相等；如果指向不同对象，他们不相等

==运算符判断相等的流程是怎样的?

  1. 如果两个值类型相同，按照===比较方法进行比较
  2. 如果类型不同，使用如下规则进行比较
  3. 如果其中一个值是 null，另一个是 undefined，它们相等
  4. 如果一个值是数字另一个是字符串，将字符串转换为数字进行比较
  5. 如果有布尔类型，将true 转换为 1，false 转换为 0，然后用==规则继续比较
  6. 如果一个值是对象，另一个是数字或字符串，将对象转换为原始值然后用==规则继续比较
  7. 其他所有情况都认为不相等

== 和 === 有何区别？

=== 不需要进行类型转换，只有类型相同并且值相同时，才返回true。

== 如果两者类型不同，首先会进行数据类型的转换。

== 数据类型的相互转换规则？

数字类型 和 其他类型的比较：

  • 数字类型和其他类型比较时，都是将其他类型先转换为Number类型，再进行比较
  • NaN和任何值比较都不相等，包括他自己。
  • 数字类型和对象比较时，先将对象转换为原始值，再进行比较
1 == '1' // true; Number('1')是1，所以1 == 1，为true
1 == '1px' // false; Number('1px')是NaN，1 != NaN，所以为false
1 == true // true;  Number(true) = 1，1 == 1，所以为true
1 == false // false;  Number(false) = 0，1 != 0，所以为false
NaN == NaN // false;
1 == null // false;  Number(null) = 0，1 != 0，所以为false
1 == undefined // false; Number(undefined) = NaN, 而NaN和谁都不相等，所以为false
1 == {} // false;  Number({}) = NaN, NaN不等于任何人，所以为false

注意：

  • []转换为Number时，空数组为0， Number([]) = 0
  • []内只有一个数字时，转换为Number后则是数组内的那个数字, Number([当前的一个数字]) = 当前的一个数字
  • 其余的数组转换成Number都是NaN
  • {}转换成Number时也是NaN

字符串类型 和 其他数据类型比较：

  • toString()
  • 字符串 == Boolean(true/false)，规则: 将字符串和Boolean都转换为数字进行比较
  • 字符串 == null，返回false
  • 字符串 == undefined，返回false
  • 字符串 == 对象，规则：将字符串转为数字，对象转为原始值，再进行比较
'12px' == true; // false
'12px' == []; // false
'12px' == 1; // false

Boolean类型 和 其他类型比较：

  • ! 先转换为Boolean，表示取反
  • !! 直接调用Boolean()，表示获取Boolean值
  • Boolean == null，返回false
  • Boolean == undefined，返回false
  • Boolean == 对象，规则：将Boolean转换为数字，将对象转换为原始值，然后比较

null 和 其他类型比较：

  • null == undefined，返回true
  • null === undefined，返回false
  • null == 对象，返回false

undefined 和 其他类型比较：

  • undefined == 对象，返回false

对象 和 对象比较：

将对象转换为原始值进行比较，比较的是各自代表的内存地址，地址相同则相等，地址不同则不相等

== 判断的优先级是最低的，肯定是先把左右两边的表达式先执行，然后将执行结果进行比较

[] == ![] 的结果

结果是true

  1. !的优先级高于==
  2. ![] 引用类型转换成boolean值都是true，因为![]为false
  3. 根据判断规则，两种类型，一种是boolean，则将boolean转为number再进行判断，false转为number变成了0
  4. 根据判断规则，两种类型，一种是number，那么将object也转换为number，空数组转换成数字，对应的值是0 【空数组转成数字是0，数组中只有一个数字，则转成number就是这个数字，其他情况均为NaN】
  5. 0 == 0 ，结果为true

<、>、<=、>=的比较规则

所有比较运算符都支持任意类型，但是比较只支持数字和字符串，所以比较必要的转换然后进行比较，转换规则如下:

  1. 如果操作数是对象，转换为原始值：如果 valueOf 方法返回原始值，则使用这个值，否则使用 toString 方法的结果，如果转换失败则报错
  2. 经过必要的对象到原始值的转换后，如果两个操作数都是字符串，按照字母顺序进行比较（他们的 16 位 unicode 值的大小）
  3. 否则，如果有一个操作数不是字符串，将两个操作数转换为数字进行比较

+运算符工作流程

  1. 如果有操作数是对象，转换为原始值
  2. 此时如果有一个操作数是字符串，其他的操作数都转换为字符串并执行连接
  3. 否则：所有操作数都转换为数字并执行加法