如何比较两个json相等

如何比较两个JSON对象是否相等：全面指南

在软件开发中，JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，被广泛应用于前后端数据交互、配置文件存储等场景，在实际开发中，我们经常需要判断两个JSON对象是否“相等”——但“相等”的定义并非简单的内容一致，还可能涉及字段顺序、数据类型、嵌套结构等细节，本文将系统介绍比较两个JSON对象相等的多种方法，从基础到进阶,并分析不同场景下的适用方案。

什么是“JSON相等”？——明确比较的核心维度

在开始比较之前，首先要明确“JSON相等”的具体含义,我们需要考虑以下维度：

1. 值相等：两个JSON对象的字段值完全相同（包括数据类型，如数字1和字符串"1"被视为不同）。
2. 结构一致：字段的嵌套结构、字段数量、字段名称完全相同（字段顺序是否影响相等性，需根据场景判断）。
3. 特殊值处理：如null、undefined（JSON标准中不支持undefined，但实际数据中可能遇到）、NaN（JSON标准中不支持，但JavaScript中可能存在）等值的比较规则。

// JSON对象A
{
  "name": "Alice",
  "age": 25,
  "hobbies": ["reading", "coding"]
}
// JSON对象B
{
  "name": "Alice",
  "age": "25",  // 数据类型不同（字符串 vs 数字）
  "hobbies": ["reading", "coding"]
}

从严格意义上，A和B不相等，因为age字段的数据类型不同，而如果字段顺序不同，但值和结构完全一致，是否算“相等”？这取决于具体需求（如某些场景下顺序无关，某些场景下顺序敏感）。

基础方法：直接比较（适用于简单场景）

使用JSON.stringify()转换为字符串后比较

原理：将两个JSON对象序列化为字符串，然后直接比较字符串是否完全一致，这种方法简单直接,但需要注意字段顺序和特殊值的处理。

示例：

const json1 = { name: "Alice", age: 25 };
const json2 = { name: "Alice", age: 25 };
const json3 = { age: 25, name: "Alice" }; // 字段顺序不同
console.log(JSON.stringify(json1) === JSON.stringify(json2)); // true
console.log(JSON.stringify(json1) === JSON.stringify(json3)); // false（因字段顺序不同）

注意事项：

• 字段顺序敏感：JSON.stringify()会按照字段顺序生成字符串，因此顺序不同的对象会被视为不等，如果忽略顺序,需要先对字段排序。
• 特殊值处理：undefined、function、Symbol等类型会被忽略（JSON.stringify()会过滤掉这些值），而NaN、Infinity会被转换为null。

  const obj1 = { a: undefined, b: NaN };
  const obj2 = { a: undefined, b: null };
  console.log(JSON.stringify(obj1)); // '{"b":null}'
  console.log(JSON.stringify(obj2)); // '{"b":null}' —— 会被误判为相等

使用或比较（仅适用于引用相同）

原理：JavaScript中的（严格相等）或（宽松相等）操作符，只有当两个变量引用同一个内存对象时才返回true，对于JSON对象（普通对象），即使内容完全相同，只要不是同一个引用，也会返回false。

示例：

const json1 = { name: "Alice" };
const json2 = { name: "Alice" };
const json3 = json1; // 引用同一个对象
console.log(json1 === json2); // false（不同引用）
console.log(json1 === json3); // true（同一引用）

适用场景：仅适用于判断两个变量是否指向同一个对象,不适用于比较内容是否相等。

进阶方法：深度比较（解决复杂场景）

当JSON对象嵌套多层、字段顺序可能不同、或需要处理特殊值时，基础方法不再适用，此时需要深度比较（Deep Comparison）,即递归比较每个字段的值和结构。

手写递归深度比较函数

核心思路：

• 首先判断两个变量的类型，类型不同则直接返回false。
• 如果是基本类型（字符串、数字、布尔值、null）,直接用比较。
• 如果是数组，依次比较每个元素（递归调用深度比较函数）。
• 如果是对象，先比较字段数量是否一致，再依次比较每个字段的值（递归调用深度比较函数）。
• 忽略字段顺序：比较时统一遍历一个对象的字段,再检查另一个对象是否包含相同字段。

示例代码：

function deepEqual(obj1, obj2) {
  // 1. 引用相同，直接返回true
  if (obj1 === obj2) return true;
  // 2. 类型不同，返回false
  if (typeof obj1 !== typeof obj2 || obj1 === null || obj2 === null) {
    return false;
  }
  // 3. 基本类型比较（已排除null）
  if (typeof obj1 !== 'object') {
    return obj1 === obj2;
  }
  // 4. 数组比较
  if (Array.isArray(obj1) || Array.isArray(obj2)) {
    if (!Array.isArray(obj1) || !Array.isArray(obj2)) return false;
    if (obj1.length !== obj2.length) return false;
    for (let i = 0; i < obj1.length; i++) {
      if (!deepEqual(obj1[i], obj2[i])) return false;
    }
    return true;
  }
  // 5. 对象比较（忽略字段顺序）
  const keys1 = Object.keys(obj1);
  const keys2 = Object.keys(obj2);
  if (keys1.length !== keys2.length) return false;
  for (const key of keys1) {
    if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
      return false;
    }
  }
  return true;
}
// 测试
const json1 = { name: "Alice", age: 25, hobbies: ["reading", { type: "sports" }] };
const json2 = { age: 25, name: "Alice", hobbies: ["reading", { type: "sports" }] };
const json3 = { name: "Alice", age: 25, hobbies: ["reading", { type: "music" }] };
console.log(deepEqual(json1, json2)); // true（忽略字段顺序）
console.log(deepEqual(json1, json3)); // false（嵌套对象值不同）

优点：

• 可自定义比较规则（如是否忽略字段顺序、是否处理特殊值）。
• 不依赖外部库,轻量级。

缺点：

• 需要手动处理各种边界情况（循环引用、特殊值等）。
• 代码相对复杂,维护成本高。

处理循环引用

如果JSON对象中存在循环引用（如对象A的某个字段引用了A本身），递归比较会导致栈溢出,需要在比较时记录已访问的对象引用。

改进后的循环引用处理：

function deepEqualWithCircular(obj1, obj2, visited = new WeakMap()) {
  if (obj1 === obj2) return true;
  if (typeof obj1 !== typeof obj2 || obj1 === null || obj2 === null) {
    return false;
  }
  if (typeof obj1 !== 'object') return obj1 === obj2;
  // 处理循环引用
  if (visited.has(obj1) && visited.has(obj2)) {
    return visited.get(obj1) === visited.get(obj2);
  }
  visited.set(obj1, true);
  visited.set(obj2, true);
  if (Array.isArray(obj1) || Array.isArray(obj2)) {
    if (!Array.isArray(obj1) || !Array.isArray(obj2)) return false;
    if (obj1.length !== obj2.length) return false;
    for (let i = 0; i < obj1.length; i++) {
      if (!deepEqualWithCircular(obj1[i], obj2[i], visited)) return false;
    }
    return true;
  }
  const keys1 = Object.keys(obj1);
  const keys2 = Object.keys(obj2);
  if (keys1.length !== keys2.length) return false;
  for (const key of keys1) {
    if (!keys2.includes(key) || !deepEqualWithCircular(obj1[key], obj2[key], visited)) {
      return false;
    }
  }
  return true;
}

使用第三方库（推荐生产环境）

在实际开发中，手写深度比较函数容易遗漏边界情况，推荐使用成熟的第三方库，它们已经处理了循环引用、特殊值、性能优化等问题。

（1