前言
在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 ] ]
Comments NOTHING