怎么手写JS递归函数实现对象深度比较

作者:闭包旅人时间:2026-11-19 13:08:06浏览:75

深入讲解如何在JavaScript中手写递归函数实现对象深度比较(deepEqual),涵盖原始类型判断、特殊对象处理、键名与层级递归比对,以及通过WeakMap解决循环引用的完整方案与测试用例。

怎么手写JS递归函数实现对象深度比较

在 JavaScript 开发中,判断两个变量是否相等是常见需求。但无论是全等运算符 === 还是 Object.is,在面对引用类型时都只检验它们是否指向同一块内存地址;如果两个对象的字面量内容完全相同但引用不同,比较结果依然是 false。手写一个递归深度比较函数(通常命名为 deepEqual),核心解决路径是:先利用基础相等性排查同引用与原始类型,再过滤非对象与 null,接着针对特殊对象类型(如 Date、RegExp)提取内部值比对,再通过比对键名集合与长度排查差异,最后对每个属性递归调用自身,同时借助 WeakMap 记录已比对的对象对以防御循环引用。本文将一步步拆解该递归函数的设计逻辑与完整实现。

一、为什么常规手段无法胜任深度比较

很多初学者会尝试直接使用 === 或 JSON.stringify 进行对象比较,但在实际场景中它们存在明显的局限性:

  • 引用比较与值比较的差异:JavaScript 中的对象属于引用类型。表达式 {} === {} 返回 false,因为引擎分别在堆内存中开辟了两个独立的存储空间。即使两个对象的属性名与值一模一样,=== 也无法检测出内部数据的等价性。
  • JSON.stringify 的陷阱:序列化字符串的方式不仅性能开销大,还存在诸多边界缺陷:它会直接忽略值为 undefined、函数或 Symbol 的属性;把 NaN 和 Infinity 序列化为 null;将 Date 对象转为字符串导致丢失类型信息;将 RegExp 转为 {};更严重的是,当对象间属性顺序不同(例如 {a:1, b:2} 与 {b:2, a:1})时序列化字符串不一致,且遇到循环引用时会直接抛出运行时异常 TypeError: Converting circular structure to JSON。
怎么手写JS递归函数实现对象深度比较
图 1:全等运算(引用比对)与递归深度比对的本质机制差异

二、递归深度比较的核心设计与决策流程

递归算法的核心在于确立基准情形(Base Case)与递归推进(Recursive Step)。如果把两个比较对象看作两棵树的根节点,深度比较本质上是先序遍历这两棵树,并在任意节点发现差异时立即短路退出返回 false。

一个健壮的 deepEqual 算法需要依次经历以下 5 个判定阶段:

  1. 基准短路(同值/同引用判断):使用 Object.is(a, b) 先行判定。如果是完全相同的引用,或者相同值的基本类型(包含 NaN === NaN 的正确处理),直接返回 true。
  2. 排除非对象与 null:若两变量未能通过第一步,且其中任何一个不是对象(typeof val !== 'object')或者为 null,则说明它们必然是不相等的原始类型或对象与非对象的比对,直接返回 false。
  3. 特殊对象类型比对:Date 和 RegExp 实例的 typeof 结果均为 'object',但它们内部封装了特定状态。对于 Date 对象,比对 a.getTime() === b.getTime();对于 RegExp 对象,比对正则源字符串 a.source === b.source 以及标志位 a.flags === b.flags。
  4. 循环引用防御(Memoization):利用传入的 WeakMap 检查这对对象是否已经在当前递归路径中被记录过。如果是,直接判定当前分支相等返回 true,防止调用栈溢出。
  5. 键名集合比对与递归子属性:提取各自自身拥有的可枚举键(Object.keys)。首先比对键数量是否相等;若数量相等,再检查对象 b 是否拥有对象 a 的每一个键;最后对每个键对应的值递归调用 deepEqual(a[key], b[key], memo)。
怎么手写JS递归函数实现对象深度比较
图 2:手写递归深度比较算法的单步决策与短路流程

三、关键细节:循环引用的识别与 WeakMap 记忆机制

深度遍历对象树时,最危险的问题是循环引用(Circular Reference)。例如对象 objA.self = objA,或者 objA.friend = objB; objB.friend = objA;。如果不对已访问过的对象做记忆化存储,递归将永远无法到达基准情形,直到触发引擎的 RangeError: Maximum call stack size exceeded。

为了解决此问题,我们使用 WeakMap 维护一个记忆缓存池:

  • 为什么选用 WeakMap:WeakMap 的键必须是对象,且持有的键是弱引用,不会阻碍垃圾回收机制(GC)。递归比对结束后,相关引用会自动释放,不会引发内存泄漏。
  • 成对记忆(Pair Mapping):在进入对象属性的子递归之前,先执行 memo.set(a, b)。若在后续深层比对中再次遇到 a,检查 memo.get(a) === b。如果匹配,说明当前这对对象已经在正在处理的路径中,可以直接认为在此分支上是等价的,返回 true 跳过死循环。
怎么手写JS递归函数实现对象深度比较
图 3:基于 WeakMap 缓存键值对切断循环引用的执行机制

四、完整可运行代码实现

结合上述分析,下面给出完整的 deepEqual 核心实现。代码注重防御性编程,使用 Object.prototype.hasOwnProperty.call 规避原型污染或无原型对象(如 Object.create(null))导致的调用异常:

/**
 * 深度比较两个 JavaScript 实体是否在值和结构上完全等价
 * @param {*} a 比较对象 A
 * @param {*} b 比较对象 B
 * @param {WeakMap} [memo=new WeakMap()] 循环引用记忆存储
 * @returns {boolean}
 */
function deepEqual(a, b, memo = new WeakMap()) {
    // 1. 基准检查:同引用或者相等的原始类型(能准确处理 NaN 与 +0/-0)
    if (Object.is(a, b)) {
        return true;
    }

    // 2. 排除非对象类型与 null(因为 typeof null === 'object')
    if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
        return false;
    }

    // 3. 特殊对象类型比对:Date
    if (a instanceof Date && b instanceof Date) {
        return a.getTime() === b.getTime();
    }

    // 4. 特殊对象类型比对:RegExp
    if (a instanceof RegExp && b instanceof RegExp) {
        return a.source === b.source && a.flags === b.flags;
    }

    // 5. 校验构造函数是否一致(例如 Array vs 普通 Object,或者不同类实例)
    if (a.constructor !== b.constructor) {
        return false;
    }

    // 6. 循环引用防御:如果已经比较过该对象对,直接认定为相等
    if (memo.has(a) && memo.get(a) === b) {
        return true;
    }
    // 记录正在比较的对象对
    memo.set(a, b);

    // 7. 比对自身可枚举属性键列表
    const keysA = Object.keys(a);
    const keysB = Object.keys(b);

    // 键数量不一致直接短路
    if (keysA.length !== keysB.length) {
        return false;
    }

    // 8. 逐一比对键名存在性及子属性值
    for (let i = 0; i < keysA.length; i++) {
        const key = keysA[i];

        // 检查对象 b 是否也拥有同样的自有属性
        if (!Object.prototype.hasOwnProperty.call(b, key)) {
            return false;
        }

        // 递归深入比对属性值
        if (!deepEqual(a[key], b[key], memo)) {
            return false;
        }
    }

    // 所有属性校验均通过
    return true;
}

五、测试用例与验证

为了验证函数的完备性,我们设计了包含原始值、嵌套结构、特殊对象以及循环引用在内的测试矩阵。在 Node.js 或任意现代浏览器控制台中运行以下示例代码:

// 1. 基础值与 NaN
console.log(deepEqual(1, 1));               // 示例输出: true
console.log(deepEqual(NaN, NaN));           // 示例输出: true
console.log(deepEqual(1, '1'));             // 示例输出: false

// 2. 嵌套对象与属性无序性
const obj1 = { name: 'Alice', details: { age: 25, tags: ['dev', 'js'] } };
const obj2 = { details: { tags: ['dev', 'js'], age: 25 }, name: 'Alice' };
console.log(deepEqual(obj1, obj2));         // 示例输出: true

// 3. 数组类型与内容比对
console.log(deepEqual([1, 2, [3, 4]], [1, 2, [3, 4]])); // 示例输出: true
console.log(deepEqual([1, 2], [1, 2, 3]));              // 示例输出: false

// 4. 特殊类型 (Date 与 RegExp)
console.log(deepEqual(new Date('2026-01-01'), new Date('2026-01-01'))); // 示例输出: true
console.log(deepEqual(/abc/gi, /abc/gi));                              // 示例输出: true
console.log(deepEqual(/abc/gi, /abc/g));                               // 示例输出: false

// 5. 循环引用测试
const circularA = { id: 100 };
circularA.self = circularA;

const circularB = { id: 100 };
circularB.self = circularB;

console.log(deepEqual(circularA, circularB)); // 示例输出: true

注意:在比对键名时,Object.keys() 只会返回对象自身拥有的可枚举属性。如果不希望忽略 Symbol 类型的属性键,可以用 Reflect.ownKeys() 代替 Object.keys()。

六、各数据类型深度比对处理规则总结

下表与总结图概括了在手写 deepEqual 递归函数时,针对 ECMAScript 常见数据类型的分支处理标准与判定依据:

怎么手写JS递归函数实现对象深度比较
图 4:JavaScript 深度比较各数据类型判定规则全景总结矩阵

手写递归深度比较不仅是前端高频面试题,也是理解深拷贝、状态快照和前端组件更新检测(如 React 的 memo 比较)的核心基础。通过明确递归终止条件、针对特殊对象进行特化处理,并利用 WeakMap 消除循环引用死循环,便能构建出一个兼顾鲁棒性与性能的对象深度比较工具函数。

作者最新文章
相关文章
更多