前言

在js中对象是引用类型,对象要相等除非是同一个引用,不然就不会相等,如下:

var obj1={0:'a',1:'b',2:'c'}
var obj2={0:'a',1:'b',2:'c'}
console.log(obj1==obj2)
console.log(obj1===obj2)

输出都为false,虽然他们内容一样。

那么当需要判断对象的内容是否都一样的时候,比如上面的obj1、obj2,该怎么做呢?

解决方法

比较完整的object比较函数looseEqual()如下

//判断两个对象是否相同(包含绝对相等和他们是否有相同的形状)
function looseEqual(a, b) {
    if (a === b) { //如果是绝对相等就直接返回true
        return true;
    }
    //如果不是绝对相等就哦按的他们是否有相同的形状
    var isObjectA = isObject(a);
    var isObjectB = isObject(b);
    if (isObjectA && isObjectB) {//两个均是对象
        try {
            var isArrayA = Array.isArray(a);
            var isArrayB = Array.isArray(b);
            if (isArrayA && isArrayB) {//如果都是数组
                if (a.length === b.length) {//如果长度相等
                    return a.every(function (e, i) {//用every和递归来比对a数组和b数组的每个元素,并返回
                        return looseEqual(e, b[i])
                    })
                }
                //长度都不等直接返回false
                return false;
            } else if (a instanceof Date && b instanceof Date) {//如果是Date 则直接getTime 比较
                return a.getTime() === b.getTime()
            } else if (!isArrayA && !isArrayB) {//对象的比较
                //拿到两个对象的key
                var keysA = Object.keys(a);
                var keysB = Object.keys(b);
                if (keysA.length === keysB.length) {//如果keys相等
                    return keysA.every(function (key) {//用every和递归来比对a对象和b对象的每个元素值,并返回
                        return looseEqual(a[key], b[key]);
                    })
                }
                //长度都不等直接返回false
                return false;
            } else {
                return false
            }
        } catch (e) {
            return false
        }
    } else if (!isObjectA && !isObjectB) {//如果都不是对象则按String来处理
        return String(a) === String(b)
    } else {
        return false
    }
}

function isObject(obj) {
    return obj !== null && typeof obj === 'object'
}

测试如下:

//字符
var str1 = "abc";
var str2 = "abc";
console.log(looseEqual(str1, str2))

//数字
var num1 = 12222;
var num2 = 12222;
console.log(looseEqual(num1, num2))

//对象
var obj1 = { 0: 'a', 1: 'b', 2: 'c' }
var obj2 = { 0: 'a', 1: 'b', 2: 'c' }
console.log(looseEqual(obj1, obj2))

//对象嵌套数组
var obj1 = { 0: 'a', 1: 'b', 2: [1, 2, 3] }
var obj2 = { 0: 'a', 1: 'b', 2: [1, 2, 3] }
console.log(looseEqual(obj1, obj2))

//类数组
var a = { 0: 'a', 1: 'b', 2: 'c', 'length': 3 }
var b = { 0: 'a', 1: 'b', 2: 'c', 'length': 3 }
console.log(looseEqual(a, b))

//数组
var list = [1, 2, 3, 4]
var list1 = [1, 2, 3, 4]
console.log(looseEqual(list, list1))

//数组嵌套
list = [1, 2, 3, [6, 7]]
list1 = [1, 2, 3, [6, 7]]
console.log(looseEqual(list, list1))

//数组嵌套对象
list = [1, 2, 3, { a: '1', b: '7' }]
list1 = [1, 2, 3, { a: '1', b: '7' }]
console.log(looseEqual(list, list1))

var d1 = new Date();
var d2 = new Date();
console.log(looseEqual(d1, d2))

var d3 = new Date();
var d4;
//使用延时来赋值d4
setTimeout(function () {
    d4 = new Date();
    console.log(looseEqual(d3, d4))
}, 1);

另一段只比较结构体对象的代码:

function isObjectValueEqual(a, b) {
    var aProps = Object.getOwnPropertyNames(a);
    var bProps = Object.getOwnPropertyNames(b);
    if (aProps.length != bProps.length) {
        return false;
    }
    for (var i = 0; i < aProps.length; i++) {
        var propName = aProps[i]

        var propA = a[propName]
        var propB = b[propName]
        // 故先判断两边都有相同键名
        if (!b.hasOwnProperty(propName)) return false
        if ((propA instanceof Object)) {
            if (this.isObjectValueEqual(propA, propB)) {
                // return true     这里不能return ,后面的对象还没判断
            } else {
                return false
            }
        } else if (propA !== propB) {
            return false
        } else { }
    }
    return true
}
var a = {
    id: 1,
    name: 2,
    c: {
        age: 3
    }
};
var b = {
    id: 1,
    name: 2,
    c: {
        age: 3
    }
}
console.log(isObjectValueEqual(a, b));//true

对象深拷贝

Object和Array都可用,只要两个参数的格式一致即可。

function deepClone(obj, newObj) {
    var newObj = newObj || {};
    for (let key in obj) {
        if (typeof obj[key] == 'object') {
            newObj[key] = (obj[key].constructor === Array) ? [] : {}
            deepClone(obj[key], newObj[key]);
        } else {
            newObj[key] = obj[key]
        }
    }
    return newObj;
}

// test object
var obj = {
    name: "123",
    sex: { age: "小花" }
};
var newObj = {};
console.log(deepClone(obj, newObj)); 
// => {name: "123",sex: {age: '小花'}}

// test Array
var arr = [1, 2, [1, 2, 3]];
var newArr = [];
deepClone(arr, newArr);
arr[2].push(5);
newArr[2].push(6);
console.log(newArr);
// => [ 1, 2, [ 1, 2, 3, 6 ] ]

A Student on the way to full stack of Web3.