除了 JSON 序列化比较，还有哪些方法可以进行深比较？

使用lodash或underscore.js库的深度比较函数

• lodash的 _.isEqual 方法：

  • 原理：lodash是一个广泛使用的JavaScript实用工具库，其 _.isEqual 方法通过递归遍历对象和数组的所有属性和元素，对不同的数据类型进行细致的比较，能够处理各种复杂的数据结构，包括循环引用等特殊情况。

  • 示例

    const _ = require('lodash');
    
    let obj1 = {
            name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
    let obj2 = {
            name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
    
    console.log(_.isEqual(obj1, obj2)); // true
    
    let obj3 = {
            name: 'Alice', age: 25, details: {
            city: 'New York' } };
    let obj4 = {
            name: 'Alice', age: 25, details: {
            city: 'New York' } };
    
    console.log(_.isEqual(obj3, obj4)); // true
    

• underscore.js的 _.isEqual 方法：

  • 原理：underscore.js同样提供了 _.isEqual 方法来进行深度比较，其实现原理与lodash类似，通过递归和类型判断等方式对对象和数组进行全面的比较，以确定它们是否在结构和值上完全相等。

  • 示例：

    const _ = require('underscore');
    
    let obj1 = {
            name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
    let obj2 = {
            name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
    
    console.log(_.isEqual(obj1, obj2)); // true
    
    let obj3 = {
            name: 'Alice', age: 25, details: {
            city: 'New York' } };
    let obj4 = {
            name: 'Alice', age: 25, details: {
            city: 'New York' } };
    
    console.log(_.isEqual(obj3, obj4)); // true
    

基于对象属性遍历和类型判断的自定义比较函数

• 原理：这种方法需要开发者手动编写比较逻辑，通过遍历对象的属性，针对不同的数据类型进行相应的比较操作。对于对象类型的属性，继续递归调用比较函数进行深度比较；对于数组类型的属性，遍历数组元素并逐个比较。
• 示例：

function customDeepEqual(obj1, obj2) {
   
  // 比较对象的类型是否相同
  if (Object.prototype.toString.call(obj1)!== Object.prototype.toString.call(obj2)) {
   
    return false;
  }

  if (typeof obj1 === 'object' && obj1!== null) {
   
    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);

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

    for (let key of keys1) {
   
      if (!obj2.hasOwnProperty(key)) {
   
        return false;
      }

      if (typeof obj1[key] === 'object' && obj1[key]!== null) {
   
        if (!customDeepEqual(obj1[key], obj2[key])) {
   
          return false;
        }
      } else {
   
        if (obj1[key]!== obj2[key]) {
   
          return false;
        }
      }
    }
  }

  return true;
}

let obj1 = {
    name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
let obj2 = {
    name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };

console.log(customDeepEqual(obj1, obj2)); // true

let obj3 = {
    name: 'Alice', age: 25, details: {
    city: 'New York' } };
let obj4 = {
    name: 'Alice', age: 25, details: {
    city: 'New York' } };

console.log(customDeepEqual(obj3, obj4)); // true

使用Proxy对象进行代理比较

• 原理：利用ES6的Proxy对象可以拦截对象的操作，通过定义 get、set 等拦截器，在访问和修改对象属性时进行额外的处理。在深度比较中，可以使用Proxy来代理对象，在属性访问时记录属性值，并递归比较属性值是否相等。
• 示例：

function deepEqualWithProxy(obj1, obj2) {
   
  const seen = new WeakSet();

  const proxyHandler = {
   
    get(target, property) {
   
      if (typeof target[property] === 'object' && target[property]!== null) {
   
        if (!seen.has(target[property])) {
   
          seen.add(target[property]);
          return new Proxy(target[property], proxyHandler);
        }
      }
      return target[property];
    }
  };

  const proxiedObj1 = new Proxy(obj1, proxyHandler);
  const proxiedObj2 = new Proxy(obj2, proxyHandler);

  return JSON.stringify(proxiedObj1) === JSON.stringify(proxiedObj2);
}

let obj1 = {
    name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
let obj2 = {
    name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };

console.log(deepEqualWithProxy(obj1, obj2)); // true

let obj3 = {
    name: 'Alice', age: 25, details: {
    city: 'New York' } };
let obj4 = {
    name: 'Alice', age: 25, details: {
    city: 'New York' } };

console.log(deepEqualWithProxy(obj3, obj4)); // true

这种方法结合了Proxy对象的特性和JSON序列化比较的优点，能够处理循环引用等复杂情况，同时又相对简洁直观。

使用第三方深度比较库，如 deep-equal、fast-deep-equal等

• deep-equal库：

  • 原理：该库专门用于深度比较JavaScript对象和数组，它通过递归遍历对象和数组的属性和元素，对各种数据类型进行准确的比较，支持处理循环引用等复杂的数据结构。

  • 示例：

    const deepEqual = require('deep-equal');
    
    let obj1 = {
            name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
    let obj2 = {
            name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
    
    console.log(deepEqual(obj1, obj2)); // true
    
    let obj3 = {
            name: 'Alice', age: 25, details: {
            city: 'New York' } };
    let obj4 = {
            name: 'Alice', age: 25, details: {
            city: 'New York' } };
    
    console.log(deepEqual(obj3, obj4)); // true
    

• fast-deep-equal库：

  • 原理：与其他深度比较库类似，fast-deep-equal通过优化的算法和数据结构，快速而准确地对对象和数组进行深度比较，能够在保证比较准确性的前提下，提高比较的效率。

  • 示例：

    const fastDeepEqual = require('fast-deep-equal');
    
    let obj1 = {
            name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
    let obj2 = {
            name: 'Alice', age: 25, hobbies: ['reading', 'swimming'] };
    
    console.log(fastDeepEqual(obj1, obj2)); // true
    
    let obj3 = {
            name: 'Alice', age: 25, details: {
            city: 'New York' } };
    let obj4 = {
            name: 'Alice', age: 25, details: {
            city: 'New York' } };
    
    console.log(fastDeepEqual(obj3, obj4)); // true
    

这些方法都可以用于进行深比较，各有优缺点。在实际应用中，可以根据具体的项目需求、性能要求、数据结构的复杂程度以及是否愿意引入第三方库等因素，选择合适的深比较方法。