关于 == 和 ===的区别

发布 : 2019-08-25 分类 : javascript 浏览 :

一、=== 的判断规则

1、如果类型不同,则不相等

2、如果两个都是数值,并且是同一个值,则相等。但例外的是 NaN !== NaN(可以通过 isNaN() 来判断是否为 NaN)

3、如果两个都是字符串,每个位置的字符都一样,那么相等,否则不相等

4、如果两个值都为true,或者都为false,那么相等

5、如果两个值都引用同一个对象或函数,那么相等

6、如果两个值都是null,或者都是undefined,那么相等

二、== 的判断规则

1、同类型比较,进行 === 比较

2、如果两个值类型不同,则根据如下规则进行类型转换再进行比较:

1)如果一个是字符换,一个是数字,则将字符串转换成数字,再进行值比较

2)如果任一值是 true,把它转换成 1 再比较;如果任一值是 false,把它转换成 0 再比较。

3)如果一个是对象,另一个是基础类型(数值或字符串),则把对象转换成基础类型的值再比较。
   对象转换成基础类型,利用它的 toString 或者 valueOf 方法。

4)高级类型与高级类型,进行指针地址比较

5)如果一个是null,一个是undefined,那么相等

三、关于类型转换

1、any -> boolean
   number -> boolean   除了 0, -0, NaN 都为 true
   string -> boolean   除了空串,都为true
   undefined、null -> boolean  为 false
   引用类型 -> boolean 都为 true, [] -> true, {} -> true

2、any -> string
   number  -> string    5 -> '5'
   boolean -> string    true -> 'true'
   数组    ->  string   [1,2] -> '1,2'
   对象    ->  string   {...} -> '[object,Object]'

2、any -> number
   string -> number   '' -> 0, '1' -> 1, 'a' -> NaN
   boolean -> number    true -> 1, false -> 0
   数组 -> number   [] -> 0, [1] -> 1, [1,2] -> NaN (空数组转为0,存在一个元素且元素为数字转为数字,其他情况转为NaN)
   null -> number  0
   undefined -> number NaN
   除了数组的引用类型 -> number 都为NaN, {} -> NaN
  • 1、any -> boolean
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// number -> boolean
console.log(Boolean(0)); // false
console.log(Boolean(-0)); // false
console.log(Boolean(NaN)); // false
console.log(Boolean(1111)); // true
// string -> boolean
console.log(Boolean('')); // false
console.log(Boolean('11')); // true
// undefined、null -> boolean
console.log(Boolean(undefined)); // false
console.log(Boolean(null)); // false
// 引用类型 -> boolean
console.log(Boolean([])); // true
console.log(Boolean({})); // true
console.log(Boolean([111])); // true
  • 2、any -> string
1
2
3
4
5
6
7
8
9
10
11
12
13
// number -> string
console.log(String(0)); // '0'
console.log(String(111)); // '111'
// boolean -> string
console.log(String(true)); // 'true'
console.log(String(false)); // 'false'
// 数组 -> string
console.log(String([])); // ''
console.log(String([1, 2])); // '1,2'
console.log(String(['1', '2', '3'])); // '1,2,3'
// 对象 -> string
console.log(String({})); // '[object Object]'
console.log(String({ a: 'a' })); // '[object Object]'
  • 3、any -> number
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// string -> number
console.log(Number('')); // 0
console.log(Number('11')); // 11
console.log(Number('a')); // NaN
// boolean -> number
console.log(Number(true)); // 1
console.log(Number(false)); // 0
// 数组 -> number
console.log(Number([])); // 0
console.log(Number([111])); // 111
console.log(Number([111, 222])); // NaN
console.log(Number(['a'])); // NaN
// undefined、null -> number
console.log(Number(undefined)); // NaN
console.log(Number(null)); // 0
// 除了数组的引用类型 -> number
console.log(Number({})); // NaN
console.log(Number(function () { })); // NaN

四、== 举例

  • 1、如果一个是字符串,一个是数值,把字符串转换成数值再进行比较。

    1
    2
    console.log('111' == 111); // true
    console.log('a' == 1); // false
  • 2、如果一个是 null、一个是 undefined,那么[相等]。

    1
    console.log(null == undefined); // true
  • 3、如果任一值是 true,把它转换成 1 再比较;如果任一值是 false,把它转换成 0 再比较。

    1
    2
    console.log(true == 1); // true
    console.log(false == 0); // true
  • 4、高级类型与高级类型,进行指针地址比较

    1
    2
    3
    4
    5
    6
    7
    8
    9
    console.log({} == {}); // false
    const obj1 = {};
    const obj2 = obj1;
    console.log(obj2 == obj1); // true

    console.log([] == []); // false
    const arr1 = [];
    const arr2 = arr1;
    console.log(arr1 == arr1); // true
  • 5、如果一个是对象,另一个是基础类型(数值或字符串),则把对象转换成基础类型的值再比较。对象转换成基础类型,利用它的 toString 或者 valueOf 方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 等号右边:
// ![] -> false -> 0 (说明: 所有引用类型转化为 boolean 都为 true, 因此 [] -> true, ![] -> false,
// 如果任一值是 true, 把它转换成 1 再比较。因此 false -> 0 )
// 等号左边:
// [] -> 0 (说明:由于等号右边是number类型, 因此需要转化为number类型)
console.log([] == ![]); // true


// 等号右边:
// !{} -> false -> 0 (说明: 所有引用类型转化为 boolean 都为 true, 因此 {} -> true, !{} -> false,
// 如果任一值是 true, 把它转换成 1 再比较。因此 false -> 0 )
// 等号左边:
// {} -> NaN (说明:由于等号右边是number类型, 因此需要转化为number类型)
console.log({} == !{}); // false


// 等号右边: 字符串: '111,222'
// 等号左边: [111, 222] -> '111,222' (说明:由于等号右边是 string 类型, 因此需要转化为 string 类型)
console.log([111, 222] == '111,222') // true


// 等号右边: 数字: 111
// 等号左边: [111, 222] -> NaN (说明:由于等号右边是 number 类型, 因此需要转化为 number 类型)
console.log([111, 222] == 111) // false

// 等号右边: 字符串: '111'
// 等号左边: [111, 222] -> '[object Object]' (说明:由于等号右边是 string 类型, 因此需要转化为 string 类型)
console.log({} == '111') // false

console.log({} == '[object Object]') // true
本文作者 : Simple
原文链接 : https://simplecodecx.github.io/blog/20190825/2c3ab5b6.html
版权声明 : 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明出处!
留下足迹