判断两个对象相等的方法

转载已于 2022-03-23 20:37:18 修改 · 1.4k 阅读

1 ·

CC 4.0 BY-SA版权

原文链接：https://blog.csdn.net/qq_25742631/article/details/105581625

文章标签：

#js

于 2021-04-15 11:31:31 首次发布

前端专栏收录该内容

50 篇文章

订阅专栏

本文介绍了判断两个对象是否相等的多种方法，包括使用JSON.stringify()、Object.assign()以及遍历对象属性的方式。对于包含嵌套对象的复杂情况，提供了一个名为isObjectChanged的函数来递归比较。此外，还提到了使用instanceof操作符检查对象的构造函数在原型链上的位置。这些方法在处理JavaScript中的对象相等性时非常实用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

判断两个对象相等的方法

使用JSON.stringify()方法将obj或array转换为字符串（但是这种方法当对象中属性的顺序不同时会判断为false）

var a = {
      name: 'xxx',
      sex: 'man',
      age: 15
    }
    var b = {
      name: 'xxx',
      sex: 'man',
      age: 15
    }
    var c = {
      name: 'xxx', 
      age: 15,
      sex: 'man'
    }
    console.log(JSON.stringify(a) == JSON.stringify(b));
    console.log(JSON.stringify(a) == JSON.stringify(c));

使用Object.assign()方法将对象合并起来（虽然属性变化不会引起错误，当对象嵌套对象这种复杂的会出现判断错误）

var a = {
      name: 'xxx',
      sex: 'man',
      age: 15
    }
var b = {
      name: 'xxx',
      sex: 'man',
      age: 15
    }
var c = {
      name: 'xxx', 
      age: 15,
      sex: 'man'
    }
    // {"name":"xxx","sex":"man","age":15}
    var d = JSON.stringify(Object.assign(a,b));
    //还可以这样写：var d = JSON.stringify(Object.assign({...a,...b}));
    // {"name":"xxx","sex":"man","age":15}
    var e = JSON.stringify(Object.assign(a,c));
    console.log(d==e);

遍历数组的方式（虽然属性变化不会引起错误，但当对象嵌套对象这种复杂的会出现判断错误）

var b = {
      name: 'xxx',
      sex: 'man',
      age: 15
    }
var c = {
      name: 'xxx', 
      age: 15,
      sex: 'man'
    }
function compare(obj1, obj2) {
      if (Object.keys(obj1).length != Object.keys(obj2).length) {
        return false;
      } else {
        for (key in obj1) {
          if (obj2.hasOwnProperty(key)) {
            if (!Object.is(obj1[key], obj2[key])) {
              return false;
            }
          } else {
            return false;
          }
        }
        return true;
      }
    }
//或者
function compare(obj1, obj2) {
      if (Object.keys(obj1).length != Object.keys(obj2).length) {
        return false;
      } else {
        for (let key in obj1) {
          if(obj1[key]!==obj2[key]){
              return false
          }
        }
        return true;
      }
 }

解决对象嵌套对象等复杂对象的方法

// 判断数据类型
function getDataType(data) {
  let type = Object.prototype.toString.call(data)
  return type.slice(8,type.length-1)
}

// 判断两个对象是否相等
function isObjectChanged(source, comparison) {
  const iterable = (data) => ['Object', 'Array'].includes(getDataType(data));
  if (!iterable(source)) {
    throw new Error(`error`);
  }

  if (getDataType(source) !== getDataType(comparison)) {
    return true;
  }
// 提取源数据的所有属性名
  const sourceKeys = Object.keys(source);
// 将对比数据合并到源数据，并提取所有属性名。
// 在这里进行对象合并，首先是要保证 对比数据>=源数据，好处一：后边遍历的遍历过程就不用做缺省判断了。
  const comparisonKeys = Object.keys({...source, ...comparison});
// 好处二：如果属性数量不一致说明数据必然发生了变化，可以直接return结果
  if (sourceKeys.length !== comparisonKeys.length) {
    return true;
  }
// 这里遍历使用some，some的特性一旦找到符合条件的值，则会立即return，不会进行无意义的遍历。
  return comparisonKeys.some(key => {
    if (iterable(source[key])) {
    // 如果源数据属于可遍历数据类型，则递归调用
      return isObjectChanged(source[key], comparison[key]);
    } else {
      return source[key] !== comparison[key];
    }
  });
}

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)) {
        //如果是引用数据类型，递归再次进行判断。两个对象引用数据类型不同，返回false
          if (!isObjectValueEqual(propA, propB)) {
              return false
            }
        } else if (propA !== propB) {
          return false
        }
      }
    return true
    }

参考文章：https://blog.csdn.net/qq_25742631/article/details/105581625
参考文章：https://blog.csdn.net/sinat_36246371/article/details/88064877

instanceof

判断构造函数的prototype是否在某个实例对象的原型链上

var str = "lalallalalalla";
console.log(str instanceof String); 
//false,str是字符串类型，不是object类型
console.log(String instanceof Object);

问题：如何判断两个对象相等？
知识点：复杂数据类型判断相等方法