js中抽象相等==

Javascript中抽象相等比较算法

undefined==null
//true
[]==[]
//false
[]==![]
//true
{}==!{}
//false
![]=={}
//false
[]==!{}
//true
[1,2]==![1]
//false

大体介绍一下JS的数据类型

ES5的数据类型分为6种：Undefined Null String Number Boolean Object,若是再加上ES6Symbol数据类型，一共7种；

null与undefined的区别：

1. null描述一个空值（空的对象引用即空指针），null被当作一个对象，typeOf null输出为'Object'（算是一个bug吧），Number(null)输出为0。undefined是预约义的全局变量，表示“缺乏值”，typeOf undefined输出为'undefined'，Number(undefined)输出为NaN；
2. null是一个关键字，而undefined并非一个关键字；

原始值概念

js的数据类型其实能够分为两种：原始类型和引用类型。原始类型又称简单类型和基本类型，包括Undefined、Null、Boolean、Number和String五种。引用类型又称复杂类型,即Object；原始类型和引用类型分别称为原始值和复杂值；

简单的说：原始值是固定而简单的值,是存放在栈(stack)中的简单数据段,也就是说,它们的值直接存储在变量访问的位置，原始类型的值被称为原始值

原始类型(primitive type)有如下五种类型:Undefined,Null,Boolean,Number,String

typeOf运算符:

条件	返回值
若是变量是undefined类型	undefined
若是变量是Boolean类型	boolean
若是变量是Number类型	number
若是变量是String类型	string
若是变量是Null类型	object
若是变量是引用类型	object

抽象相等算法

用Type(z)表明z的数据类型，比较运算 x==y，其中x和y是值，产生true或false。
    1.Type(x)与Type(y)相同：
        a.若是Type(x)为Undefined或Null,则返回true
           
        b.若是Type(x)为Number,则：
            i.若x为NaN，返回false
            ii.若y为NaN，返回false
            iii.若x与y数值相等，返回true
            iiii.若x为+0，y为-0，返回true
            iv.若x为-0，y为+0，返回true
            v.返回false
            
        c.若是Type(x)为String,则x和y对应位置的字符彻底同样才返回true,不然返回false,
        
        d.若是Type(x)为Boolean,则相同值返回true,不然false
        
        f.当x和y引用同一对象时，返回true，不然，返回false
            
    2.x为undefined,y为null,返回true，反之亦然
            
    3. Type(x)为String,Type(y)为Number,则返回比较ToNumber(x) == y，反之亦然
            
    4.Type(x)为Boolean,则返回比较ToNumber(x)==y的结果，反之亦然

    5.Type(x)为String或Number,Type(y)为Object,则返回比较ToPrimitive(y) == x
    
    6.返回false

再来看看ToBoolean，ToNumber，ToPrimitive三个运算符的定义：

ToBoolean

输入类型	结果
Undefined	false
Null	false
Boolean	不转换
Number	若是参数是-0，+0或NaN，结果为false，不然为true
String	若是参数是空字符串（长度为零），结果为false，不然为true
Object	true

ToNumber

输入类型	结果
Undefined	NaN
Null	+0
Boolean	参数为true，结果为1，参数为false，结果为+0
Number	不转换
String	参见下文的文法和注释
Object	应用下步骤：一、设原始值为ToPrimitive(输入参数，暗示，数值类型)。二、返回ToNumber(原始值)

ToPrimitive

ToPrimitive运算符接收一个值，和一个可选的指望类型做参数。ToPrimitive运算符把其值参数转换为非类型对象。若是对象有能力被转换为不止一种原语类型，可使用可选的 指望类型 来暗示那个类型。

输入类型	结果
Undefined	不转换
Null	不转换
Boolean	不转换
Number	不转换
String	不转换
Object	返回该对象的默认值。对象的默认值由指望类型传入做为hint参数调用对象内部方法[DefaultValue]获得

** ToPrimitive这个方法，参照火狐MDN上的文档介绍，大体意思以下：

ToPrimitive(obj,preferredType)

JS引擎内部转换为原始值ToPrimitive(obj,preferredType)函数接受两个参数，第一个obj为被转换的对象，第二个
preferredType为但愿转换成的类型（默认为空，接受的值为Number或String）

在执行ToPrimitive(obj,preferredType)时若是第二个参数为空而且obj为Date的实例时，此时preferredType会
被设置为String，其余状况下preferredType都会被设置为Number若是preferredType为Number，ToPrimitive执
行过程如
下：

1. 若是obj为原始值，直接返回；
2. 不然调用 obj.valueOf()，若是执行结果是原始值，返回之；
3. 不然调用 obj.toString()，若是执行结果是原始值，返回之；
4. 不然抛异常。

若是preferredType为String，将上面的第2步和第3步调换，即：

1. 若是obj为原始值，直接返回；
2. 不然调用 obj.toString()，若是执行结果是原始值，返回之；
3. 不然调用 obj.valueOf()，若是执行结果是原始值，返回之；
4. 不然抛异常

Ok,到如今，咱们须要了解,toString方法和valueOf方法；

toString用来返回对象的字符串表示。

let obj = {name:"Tom"}; //"[object Object]"
    let obj = {}; //"[object Object]"
    let arr = [1,2];    //"1,2"
    let arr = [];    //""
    let str = "1";      //"1"
    let num = 1;        //"1"
    let boo = true;     //"true"
    let date = new Date();      //"date Sat Mar 24 2018 00:23:12 GMT+0800 (CST)"
    let nul = null;     //报错
    let und;            //报错

valueOf方法返回对象的原始值，多是字符串、数值或bool值等，看具体的对象。

let obj = {name:"Tom"}; //{name:"Tom"}
    let arr = [1,2];    //[1,2]
    let str = "1";      //"1"
    let num = 1;        //1
    let boo = true;     //true
    let date = new Date();      //1521822331609
    let nul = null;     //报错
    let und;            //报错

简单理解：原始值指的是[Null,Undefined,String,Boolean,Number]五种基本数据类型之一

总结一下==运算的规则：

1. undefined == null，结果是true。且它俩与全部其余值比较的结果都是false。

2. String == Boolean，须要两个操做数同时转为Number。

3. String/Boolean == Number，须要String/Boolean转为Number。

4. Object == Primitive(原始值)，须要Object转为Primitive(具体经过valueOf和toString方法)。

栗子

undefined==null
//true
[]==[]
//false
[]==![]
//true
{}==!{}
//false
![]=={}
//false
[]==!{}
//true
[1,2]==![1]
//false

undefined==null

结果为true，不用解释了，记住就好了

[]==[]

1. 先看这两个的类型，typeOf([])获得的是'object'
2. 抽象相等算法1-f,引用同一类型的才算相等
3. 返回false

[]==![]

1. !取反运算符的优先级高于==,所以先算出![]这个得值，再去使用抽象相等算法进行比较
2. 取反运算符会先调用方法ToBoolean，再去取反
3. ToBoolean([])返回的是true，所以![]应该为false
4. []==![]转换为了[]==false
5. 根据抽象相等算法4条，则咱们能够比较[]==ToNumber[false]的值，则能够获得[]==0
6. 再根据抽象相等算法5条，比较ToPrimitive([])==0
7. 因为[]不是Date类型，因此先获得[].valueOf()的值，为[]
8. 再获得[].toString()的值，为""的字符串
9. 以上7,8部可合并为一步即比较[].valueOf().toString(),获得""字符串，此时[]转换为了原始值类型（即五种基本类型中的一种）了。
10. 根据抽象相等算法3，则能够比较ToNumber("")==0，到这里[]==![]转化为了0==0
11. 返回true

{}==![]

1. 表达式右侧，重复上一次的1-5步，能够获得{}==0
2. 根据抽象相等算法5条，ToPrimitive({})==0，获得{}.valueOf().toString()获得一个字符串"[object Object]"，是原始类型
3. 根据抽象相等算法3，最后比较ToNumber("[object Object]")==0，转变为1==0
4. 返回false

...

其他的栗子本身算一算吧

结语

本身从新写了写一遍整理了一下思路，若是什么地方没有讲清楚，请指出；

参考：

• 剖析js中各类蛋疼的类型转换
• Javascript中抽象相等比较算法
• 等...文章