JS 中如何实现大对象深度对比

关键词：JS对象对比

在JavaScript中，可以使用递归的方式实现大对象的深度对比。以下是一个示例函数，用于比较两个大对象的每个属性是否相等：

function deepEqual(obj1, obj2) {
  // 检查是否为同一个引用
  if (obj1 === obj2) return true;

  // 检查类型
  if (
    typeof obj1 !== "object" ||
    obj1 === null ||
    typeof obj2 !== "object" ||
    obj2 === null
  ) {
    // 处理 NaN 这种特殊情况
    return isNaN(obj1) && isNaN(obj2) && obj1 !== obj1 ? true : obj1 === obj2;
  }

  // 检查对象的键数
  let keys1 = Object.keys(obj1);
  let keys2 = Object.keys(obj2);

  if (keys1.length !== keys2.length) return false;

  // 递归对比每个属性
  for (let key of keys1) {
    if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
      return false;
    }
  }

  return true;
}

下面是一些测试用例：

// 测试用例
function runTests() {
  // 嵌套 JSON 对象
  const obj1 = {
    a: 1,
    b: {
      c: [1, 2, { d: 3 }],
      e: "test",
    },
    f: { g: null },
  };

  const obj2 = {
    a: 1,
    b: {
      c: [1, 2, { d: 3 }],
      e: "test",
    },
    f: { g: null },
  };

  const obj3 = {
    a: 1,
    b: {
      c: [1, 2, { d: 4 }], // 这里的 d 值不同
      e: "test",
    },
    f: { g: null },
  };

  const obj4 = {
    a: 1,
    b: {
      c: [1, 2, { d: 3 }],
      e: "different",
    },
    f: { g: null },
  };

  const obj5 = {
    a: 1,
    b: {
      c: [1, 2, { d: 3 }],
      e: "test",
    },
  };

  const obj6 = {
    a: 1,
    b: {
      c: [1, 2, { d: 3 }],
      e: "test",
    },
    f: { g: null },
    extra: "value", // 额外的属性
  };

  // 运行测试
  console.assert(deepEqual(obj1, obj2) === true, "Test Case 1 Failed");
  console.assert(deepEqual(obj1, obj3) === false, "Test Case 2 Failed");
  console.assert(deepEqual(obj1, obj4) === false, "Test Case 3 Failed");
  console.assert(deepEqual(obj1, obj5) === false, "Test Case 4 Failed");
  console.assert(deepEqual(obj1, obj6) === false, "Test Case 5 Failed");

  console.log("All test cases passed");
}

// 运行测试
runTests();

在上述示例中，deepEqual函数会递归比较两个对象的每个属性的值，包括嵌套的对象或数组。如果两个对象是相等的，则返回true，否则返回false。

注意，该函数不会检查函数、正则表达式、日期等复杂类型的值。