JavaScript值全等判断

　　作为开发员，很多时候拿到数据之后都是要做数据判断，比较特别的情况就是我们需要做数组判断和对象判断，经常的我们就array === array ,object === object;但是可惜是我们得到的结果是false，可是明明属性名和值都是一样的，为什么就返回false。那是因为这两个压根就是不是同一个数组或者同一个对象，怎么理解呢，就是两个人有着同样的外貌，同样的性格等等，但是他们不是同一个人。其实我们之所以要匹配数组对象是否全等，我们也仅仅是想看他们里面的内容是否是一样，那么我就只需要判断他们的内容是否是一样就行了。

　　由于对象和数组并不能用全等判断，需要对里面的值进行判断，因此我们就需要判断当我们遇到数组和对象时，另外进行判断。如果我们遇到了对象，我们就判断对象长度是否一致，如果对象长度一致后，我们就往下判断，每一个属性名，如果都一样，就判断值一不一样，如果这三步都是一样的，那就代表这一个对象是一样的。数组也同理，对每个值进行判断。当然特殊的情况，就是数组对象，或者对象包含数组，因此我们再深层的去判断，所以我们会形成递归函数。

一.数值全等匹配

    /*
    * 数值全等匹配
    * @params data1:匹配数据1
    * @params data2:匹配数据2
    * */
    function equal(data1,data2){
        if(data1.constructor === data2.constructor){
            switch (data1.constructor){
                case Object:{
                    if(!ObjectEqual(data1,data2)){
                        return false;
                    }
                    break;
                }
                case Array:{
                    if (!ArrayEqual(data1, data2)) {
                        return false;
                    }
                    break;
                }
                default:{
                    if (data1 !== data2) {
                        return false;
                    }
                }
            }
            return true;
        }else{
            return false;
        }
    };

数组全等

    /*
    * 数组全等匹配
    * */
    function ArrayEqual(array1, array2) {
        if (array1.length === array2.length) {
            for (let i in array1) {
                if (array1[i].constructor === array2[i].constructor) {
                    switch (array1[i].constructor) {
                        case Object: {
                            if (!ObjectEqual(array1[i], array2[i])) {
                                return false
                            }
                            break;
                        }
                        case Array: {
                            if (!ArrayEqual(array1[i], array2[i])) {
                                return false;
                            }
                            break;
                        }
                        default: {
                            if (array1[i] !== array2[i]) {
                                return false;
                            }
                            break;
                        }
                    }
                } else {
                    return false;
                }
            }
            return true;
        } else {
            return false
        }
    }

对象全等

    /*
    * 对象全等匹配
    * */
    function ObjectEqual(object1, object2) {
        let aProps = Object.getOwnPropertyNames(object1);
        let bProps = Object.getOwnPropertyNames(object2);
        if (aProps.length === bProps.length) {
            for (let i in aProps) {
                if (aProps[i] !== bProps[i] || object1[aProps[i]].constructor !== object2[bProps[i]].constructor) {
                    return false;
                } else {
                    switch (object1[aProps[i]].constructor) {
                        case Object: {
                            if (!ObjectEqual(object1[aProps[i]], object2[bProps[i]])) {
                                return false
                            }
                            break;
                        }
                        case  Array: {
                            if (!ArrayEqual(object1[aProps[i]], object2[bProps[i]])) {
                                return false;
                            }
                            break;
                        }
                        default: {
                            if (object1[aProps[i]] !== object2[bProps[i]]) {
                                return false;
                            }
                            break;
                        }
                    }
                }
            }
            return true;
        } else {
            return false;
        }
    }