我们在面试的过程中，肯定会被问到与=的区别，常见的误区是==检查值是否相等，===检查值和类型是否相等，这样其实不正确，下面相关知识点介绍。

==：宽松相等

===：严格相等

他们都是用来判断两个值是否相等，区别是在判断条件上，简单的说就是，==允许在想等的比较重进行强制类型转换，===不允许

知道上面这些面试这个知识点是绰绰有余的，下面是更详细的介绍与列子（建议若是有看不懂的点，可以去就看笔者另一篇博客，JS中强制转换）：

抽象相等

在ES5中 “抽象相等比较算法”定义了==运算符的行为，该算法涵盖了可能出现的类型组合与它们强制类型转换的方式

注意：

NAN不等于NAN

-0等于0

==在比较两个不同的类型的值的时候会发生隐式强制转换，会将 其中的一或两个值变为同一种类型而进行比较

1、字符串与数字之间的比较

    <script>
      var a = "42";
      var b = 42;
      console.log(a == b);
      console.log(a === b);
    </script>

这里举出简单的列子，我们说会进行隐式的强制类型转换，而=不会，那在a==b的过程中是字符串的a转换为了数字型还是数值型的b转换为了字符型的a？在ES5中是这样定义的：

1、如果type(x)是数字，type(y)是字符串，则返回x==ToNumber(y)的结果

2、如果type(x)是字符串，type(y)是数字，则返回ToNumber(y)==y的结果

也就是把是字符串的操作数隐式转化为数字型在进行比较，这里对值类型的强制转换在我另一篇博客中有详细的介绍

2、其他类型和布尔型之间的比较

    <script>
      var a = "42";
      var b = true;
      console.log(a == b);
      console.log(a === b);
    </script>

这里的比较规则如下：

1、如果type(x)是布尔型，则返回ToNumber(x)==y的结果

2、如果type(y)是布尔型，则返回x==ToNumber(y)的结果

就是通过隐式的强制类型转换把布尔型转换为数字型

这里的对比的过程中是：

1、布尔型转换为数字型

2、字符串型转换为数字型

3、null和undefined之间的相等比较

    <script>
      var a = null;
      var b = undefined;
      console.log(a == b);
      console.log(a === b);
    </script>

前面提过的比较过程中会发生隐式强制类型转换，而null的数字型是0，undefined的数字型是NAN，0NAN?肯定是错误的，但是null==undefined返回的是true，原因如下：

1、如果x为null，y为undefined，则返回结果为true

2、如果x为undefined，y为null，则返回结果为true

也就是说，在==中null和undefined其实是一回事，可以互相进行隐式强制类型转换

注意：在==中null和undefined相等，他们自身也与其自身相等，除此之外其他值都不和他们想等，如下：

    <script>
      var a = null;
      var b = false;
      console.log(a == b);
      console.log(a === b);
    </script>

这里 我们应该遵循的是null和undefined之间的相等比较规则，而不是把false转化为0，null转化为0，再去比较，null只与自身相等或undefined，而非其他值！

4、对象和非对象之间的比较

首先先了解一下规则：

1、如果type(x)是字符串或是数字，type(y)是对象，则返回x==ToPrimitive(y)的结果

2、如果type(x)是对象，type(y)是字符串或是数字，则返回ToPrimitive(y)==y的结果

ToPrimitive不了解的可以去百度下，这里简单的做下解释，这个方法中有一个valueOf()方法，返回的就是这里面的值

简单的理解就是，那个操作数是对象就转换对应的操作数

如下列：

    <script>
      var a = 42;
      var b = [42];
      console.log(a == b);
      console.log(a === b);
    </script>

    <script>
      var a = "42";
      var b = Object(a);
      console.log(a == b);
      console.log(a === b);
    </script>

注意的是null、undefined、NAN并没有遵循这个规则，因为null、undefined并没有对应的封装对象，所以不能够被封装，NAN能够被封装为数字封装对象，但是NAN!==NAN,下面简单用列：

    <script>
      var a = undefined;
      var b = Object(a);
      console.log(a == b);
      console.log(a === b);
    </script>

5、假值得相等比较

我们知道，假值如下：

null、undefined、+0、-0、NAN、false、“”

这里 简单举出一些列子：

    <script>
      "0" == null; //false
      "0" == undefined; //false
      "0" == false; //true
      "0" == NAN; //false
      "0" == 0; //true
      "0" == ""; //false

      false == null; //false
      false == undefined; //false
      false == NAN; //false
      false == 0; //true
      false == ""; //true
      false == []; //true
      false == {}; //false

      "" == null; //false
      "" == undefined; //false
      "" == NAN; //false
      "" == 0; //true
      "" == []; //true
      "" == {}; //false

      0 == null; //false
      0 == undefined; //false
      0 == NAN; //false
      0 == []; //true
      0 == {}; //false
    </script>

上面就是一些简单得列子，我们可以通过之前得知识点来进行判断它们是否相等

当然还有一些其他的情况比如：

[]==![]

这里是不是觉得返回的是false？

其实返回的是true，原因如下

1、！表示进行隐式强制转换为布尔型，再取反，而[]的布尔值为true,!true的话就是false

2、所以就是[]==false

3、这里[]类型转换为Number就是0，false也是0，0==0，自然返回的就是true

2==[2] //true
""==[null] //true
0 == "\n" //true
["0"] == ["0"] //false

var a ={b:1}
var b={b:1}
a == b // false

var a =function(){}
var b =function(){}
a == b // false

上面是一些对引用类型的列子，也就是object、Array、function的，引用类型的存储方式是堆存储，所以变量a、b存放的只是他们的地址而已，自然是不想等的。而js中的基本类型就不会出现这种情况。

总结

上面简单的探讨了一下在使用==会发生上面，以及不同类型的规则，JS中的知识点就是一个连接着一个，==在判断相等的过程中会发生隐式的强制类型转换，对于JS中的强制类型转换可以看我这篇博客https://blog.csdn.net/qq_43376559/article/details/121872771?spm=1001.2014.3001.5501

​