深入解析JavaScript中对象浅比较与深比较的内存机制、核心区别、边界陷阱及工业级代码实现方案,涵盖Object.is优化、循环引用WeakMap拦截与React工程实践。
JS对象浅比较与深比较的区别及实现方案
时间:2026-11-18
浏览:503
文章目录
在 JavaScript 中,比较两个变量是否“相等”是业务逻辑与框架性能优化的核心基石。JavaScript 对对象类型的比对默认基于“内存引用地址”,即便两个对象包含完全相同的属性和值,使用 === 判断也会返回 false。解决这一问题的两个主流方向分别是:只遍历比对第一层属性值的浅比较(Shallow Comparison),以及递归深入所有层级比对节点值的深比较(Deep Comparison)。本文直接剖析二者的底层区别、内存判定机制、典型缺陷与陷阱,并给出工业级的纯手写实现方案与工程选型建议。
一、JavaScript 对象比较的底层原理与核心差异
理解浅比较与深比较的前提,是厘清 JavaScript 的内存分配模型。原始类型(如 Number、String、Boolean)的值直接存储在栈内存中,值相同即全等;而对象(包括普通对象、数组、函数等引用类型)存储在堆内存中,栈内存中保存的仅仅是指向该堆内存地址的指针。
当执行 objA === objB 时,V8 引擎仅比对两个指针存储的内存地址,这被称为引用比较(Reference Equality)。而在实际开发中,我们更多需要判断两者的“内容是否一致”,这就引出了两种不同深度的内容比较:
- 浅比较(Shallow Equality):首先检查引用是否相同;若不同,则提取对象自身拥有的全部第一层属性名,比对属性数量是否一致,并使用类似
Object.is的机制逐一核对每个属性值。对于嵌套对象,它只比较嵌套对象的引用指针,不会递归展开。 - 深比较(Deep Equality):不仅比对第一层属性,当发现属性值依然是对象或数组时,会顺着引用关系递归进入子树,直到所有的末端叶子节点(原始值)全部匹配。只有当所有层级的结构与原始值都完全相同时,才判定两个对象相等。
为了直观说明区别,看以下具有嵌套子对象的场景:
const baseRole = { role: 'admin', level: 2 };
// 场景 1:完全独立的两个对象,内容相同
const user1 = { id: 101, config: { theme: 'dark' } };
const user2 = { id: 101, config: { theme: 'dark' } };
// 场景 2:共享嵌套引用的两个对象
const user3 = { id: 101, roleInfo: baseRole };
const user4 = { id: 101, roleInfo: baseRole };
// 1. 引用比较
console.log(user1 === user2); // false (不同堆地址)
// 2. 浅比较判断
// user1 与 user2:config 是两个独立创建的对象,指针不同,浅比较返回 false
// user3 与 user4:roleInfo 指向同一个 baseRole 引用,浅比较返回 true!
// 3. 深比较判断
// user1 与 user2:递归进入 config 比对 theme 属性,深比较返回 true
从上面的例子可以看出:浅比较对嵌套对象极其敏感,一旦子对象不是同一个引用,浅比较就会判定为不相等。这正是浅比较计算速度极高(复杂度仅为 O(K),K 为第一层键数量)的原因,也是它无法感知深层内容一致性的边界所在。
二、浅比较(Shallow Compare)的实现方案与步骤拆解
在 React 的 PureComponent、React.memo 以及 Redux 的 useSelector 比较器中,浅比较是最高频调用的工具函数。一个标准、严谨的 shallowEqual 必须处理好 Object.is 的边界(如 NaN === NaN 为 true,而 +0 === -0 为 false),并且准确过滤原型链继承属性。
2.1 规范执行步骤
- 同一性检查:通过
Object.is(objA, objB)先行判断。如果两者本来就是同一个内存指针,或者是相同的原始值(包括NaN与NaN),直接返回true,耗时仅O(1)。 - 对象有效性过滤:若第一步未通过,检查两者是否均为非 null 的 object。如果任一参数不是对象类型,或者为
null(typeof null === 'object'是 JS 著名历史包袱),直接返回false。 - 自有键数量比对:使用
Object.keys()分别获取二者的自有可枚举属性列表。如果keysA.length !== keysB.length,说明属性数量不匹配,直接返回false。 - 遍历第一层属性逐项比对:使用
for循环遍历keysA,通过Object.prototype.hasOwnProperty.call(objB, key)确认objB自身也显式具备该键;接着使用Object.is(objA[key], objB[key])比对值。遇到任何不匹配立即中断循环返回false。 - 全部匹配:循环完整执行完毕,返回
true。
2.2 完整代码实现
/**
* 工业级浅比较函数 shallowEqual
* @param {*} objA 比对目标 A
* @param {*} objB 比对目标 B
* @returns {boolean} 是否浅层相等
*/
function shallowEqual(objA, objB) {
// 1. 同引用检查与特殊原始值 (NaN, +0/-0) 判定
if (Object.is(objA, objB)) {
return true;
}
// 2. 必须都为有效非空对象
if (
typeof objA !== 'object' || objA === null ||
typeof objB !== 'object' || objB === null
) {
return false;
}
const keysA = Object.keys(objA);
const keysB = Object.keys(objB);
// 3. 自身属性数量不等,直接判否
if (keysA.length !== keysB.length) {
return false;
}
// 4. 遍历第一层自身属性值
const hasOwn = Object.prototype.hasOwnProperty;
for (let i = 0; i < keysA.length; i++) {
const key = keysA[i];
// 目标 B 必须拥有此自有属性,且第一层值在 Object.is 下一致
if (!hasOwn.call(objB, key) || !Object.is(objA[key], objB[key])) {
return false;
}
}
return true;
}
// 验证用例
console.log(shallowEqual(1, 1)); // true (原始值匹配)
console.log(shallowEqual(NaN, NaN)); // true (Object.is 特性)
console.log(shallowEqual({ a: 1 }, { a: 1 })); // true (一层对象内容相等)
console.log(shallowEqual({ a: { b: 1 } }, { a: { b: 1 } })); // false (嵌套对象指针不同)
objB.hasOwnProperty(key),因为当对象是通过 Object.create(null) 创建或者原型链被覆写时,该方法不存在或不可靠。务必使用 Object.prototype.hasOwnProperty.call(objB, key)。
三、深比较(Deep Compare)的实现方案与陷阱防御
深比较需要深入对象内部进行结构遍历,处理场景远比浅比较复杂。如果仅仅简单递归调用自身,很容易在面对以下边界条件时产生严重故障:
- 循环引用问题:对象 A 引用了对象 B,对象 B 又引用了对象 A。无终止条件的递归会迅速耗尽调用栈,抛出
Uncaught RangeError: Maximum call stack size exceeded。 - 特殊内建类型比对:
Date对象与RegExp对象的Object.keys()为空数组,若按普通对象比对会导致不同的时间或正则被误判为相等。 - 原型与集合类型:
Array与Object的遍历方式不同,Map与Set的键值判定需要特殊的迭代机制。
3.1 常见偷懒做法的致命缺陷:JSON.stringify
部分初学者喜欢使用 JSON.stringify(a) === JSON.stringify(b) 进行“快速深比较”,该方案在严谨的工程项目中属于高危反模式:
- 属性丢失与静默篡改:如果属性值为
undefined、Function或Symbol,序列化时该属性会被直接剔除;如果是NaN、Infinity,会被转换为null;Date对象会被转为 ISO 字符串。 - 键顺序敏感:
JSON.stringify({ a: 1, b: 2 })生成'{"a":1,"b":2}',而JSON.stringify({ b: 2, a: 1 })生成'{"b":2,"a":1}',导致内容完全一致的对象被判定为不相等。 - 循环引用崩溃:包含循环引用的对象传入
JSON.stringify会直接抛出TypeError: Converting circular structure to JSON。
3.2 工业级深比较完整实现(支持循环引用与特殊类型)
利用 WeakMap 缓存已被比对过的对象对,可以在遍历有向有环图时准确拦截重复节点,阻断死循环:
/**
* 工业级深比较函数 deepEqual
* @param {*} a 目标 A
* @param {*} b 目标 B
* @param {WeakMap} [seen=new WeakMap()] 循环引用备忘录
* @returns {boolean} 是否深度相等
*/
function deepEqual(a, b, seen = new WeakMap()) {
// 1. 同一性判定 (原始类型全等、相同引用、NaN)
if (Object.is(a, b)) {
return true;
}
// 2. 过滤非对象类型与 null (未通过步骤 1 的基本类型直接返回 false)
if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
return false;
}
// 3. 严格类型标签比对 (规避 Array 与 Object 混淆等情况)
const tagA = Object.prototype.toString.call(a);
const tagB = Object.prototype.toString.call(b);
if (tagA !== tagB) {
return false;
}
// 4. 循环引用拦截保护 (避免递归爆栈)
if (seen.has(a)) {
return seen.get(a) === b;
}
seen.set(a, b);
// 5. 特殊内建对象处理
// 5.1 日期对象:比对时间戳数值
if (tagA === '[object Date]') {
return a.getTime() === b.getTime();
}
// 5.2 正则表达式:比对 source 表达式和修饰符 flags
if (tagA === '[object RegExp]') {
return a.source === b.source && a.flags === b.flags;
}
// 5.3 Map 结构比对
if (tagA === '[object Map]') {
if (a.size !== b.size) return false;
for (const [key, val] of a) {
if (!b.has(key) || !deepEqual(val, b.get(key), seen)) {
return false;
}
}
return true;
}
// 5.4 Set 集合比对 (转化为数组递归核对)
if (tagA === '[object Set]') {
if (a.size !== b.size) return false;
const arrayA = Array.from(a);
const arrayB = Array.from(b);
return deepEqual(arrayA, arrayB, seen);
}
// 6. 普通数组与纯对象比对
const keysA = Reflect.ownKeys(a);
const keysB = Reflect.ownKeys(b);
// 属性数量不一致立即返回 false
if (keysA.length !== keysB.length) {
return false;
}
// 逐一递归比较所有键及值
const hasOwn = Object.prototype.hasOwnProperty;
for (let i = 0; i < keysA.length; i++) {
const key = keysA[i];
// 保证 b 包含该属性,且对应的值递归深度相等
if (!hasOwn.call(b, key) || !deepEqual(a[key], b[key], seen)) {
return false;
}
}
return true;
}
// 验证测试:循环引用对象
const nodeA = { id: 1 };
nodeA.self = nodeA;
const nodeB = { id: 1 };
nodeB.self = nodeB;
console.log(deepEqual(nodeA, nodeB)); // 输出: true (安全识别循环结构,未发生爆栈)
// 验证测试:特殊内置对象
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({ a: [1, { b: 2 }] }, { a: [1, { b: 2 }] })); // true
四、深浅比较的工程选型与性能权衡矩阵
在实际工程架构中,并没有“深比较一定优于浅比较”或反之的说法,选用何种比较方式完全取决于执行频次与数据结构约束。
| 比对方式 | 典型算法/API | 时间复杂度 | 嵌套支持 | 内存消耗 | 核心适用场景 |
|---|---|---|---|---|---|
| 引用全等 | === / Object.is |
O(1) |
不支持 | 极低 (无额外开销) | React useState、Redux 顶层 State 变更捕获、不可变数据检查 |
| 浅比较 | shallowEqual |
O(K) (K为键数) |
仅限第 1 层 | 低 (轻量数组遍历) | React.memo、shouldComponentUpdate、Redux useSelector |
| JSON 序列化 | JSON.stringify |
O(N) (字符串开销大) |
全深度 (受限) | 中偏高 (构建临时大字符串) | 快速原型验证、简单纯 JSON 数据配置对比(避免在生产核心逻辑使用) |
| 递归深比较 | deepEqual / Lodash isEqual |
O(N) (N为总节点数) |
全深度完整支持 | 中 (递归栈 + WeakMap) | 复杂表单脏检查、单元测试断言、本地持久化配置差异同步 |
4.1 为什么 React 默认只采用浅比较?
前端组件在用户交互、高频打字或滚动动画时,每一秒钟可能触发几十上百次组件重绘。如果在每次重绘前都执行深比较,当组件的 props 中挂载了树形数据、大型表格或嵌套列表时,深比较的递归耗时可能长达数毫秒甚至数十毫秒,远超 16.6ms 的帧预算,直接造成浏览器主线程掉帧卡顿。
因此,现代前端范式(如 React、Redux)统一推崇不可变数据理念(Immutable Data Pattern):当嵌套属性发生改变时,开发者必须复制并生成新的父级引用。这样渲染器仅凭廉价的 shallowEqual 就能以极高的性能判定数据是否改变,从而兼顾了准确性与渲染流畅度。
4.2 何时必须使用深比较?
- 复杂表单离开时的脏检查:用户在多步骤表单中修改了深层级嵌套字段,离开页面前需要精准判断用户是否真正改动了内容以弹出保存确认框。此类场景仅在离开时触发一次,精确度权重远高于毫秒级性能。
- 配置项持久化比对:前端从 IndexedDB 或后端读取本地草稿配置,在网络同步前需要比对深层差异,避免向服务器提交无用的冗余更新请求。
- 自动化测试与状态快照断言:在 Jest 或 Vitest 中验证复杂状态树的变更结果。
五、总结与核心要点回顾
- 本质区别:JavaScript 对象的
===永远是比对堆内存地址。浅比较在第一层属性上进行Object.is比对,遇到嵌套对象退化为引用比对;深比较则递归深入子节点,完全比对末端原始值。 - 浅比较要诀:先比引用,再比非空与类型,接着比自身键数量,最后循环遍历比对自有属性值。务必使用
Object.prototype.hasOwnProperty.call规避原型污染。 - 深比较要诀:必须具备防御意识,引入
WeakMap规避循环引用导致的递归爆栈;使用Object.prototype.toString.call区分数组与普通对象;对Date、RegExp、Map等内建对象做特化分支比对。严禁无节制使用JSON.stringify替代深比较。 - 架构落地原则:高频 UI 响应与状态驱动场景坚持不可变数据 + 浅比较;低频表单审计、持久化存储及断言场景采用健壮深比较。
实用工具推荐
绿化、压缩、噪点和虚拟水印,自由调节做旧程度。
选择画质和输出格式,预览压缩前后的大小。