03.10.2 深拷贝与类型判断
所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.10 前端手写实现
覆盖范围
- 类型判断:typeof、instanceof、Object.prototype.toString、constructor、Array.isArray
- 浅拷贝与深拷贝:spread、Object.assign、structuredClone、JSON 序列化
- 循环引用:WeakMap 缓存访问路径
- 特殊对象:Map、Set、Date、RegExp、Symbol、ArrayBuffer、TypedArray
- 与 structuredClone、lodash.cloneDeep 的对照
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 03.10.2-001 | 手写深拷贝并处理循环引用 | 进阶 | ★★★★★ |
| 03.10.2-002 | typeof 与 Object.prototype.toString 的区别 | 基础 | ★★★★★ |
| 03.10.2-003 | 浅拷贝与深拷贝的边界 | 基础 | ★★★★★ |
| 03.10.2-004 | JSON.parse(JSON.stringify) 有哪些坑 | 进阶 | ★★★★★ |
| 03.10.2-005 | structuredClone 支持哪些类型,不支持哪些 | 进阶 | ★★★★ |
| 03.10.2-006 | 如何正确判断数组与普通对象 | 基础 | ★★★★ |
| 03.10.2-007 | Symbol 与函数在深拷贝中的处理 | 高级 | ★★★ |
| 03.10.2-008 | 如何实现 type 函数返回精确类型字符串 | 进阶 | ★★★ |
03.10.2-001 手写深拷贝并处理循环引用
一句话结论
深拷贝递归遍历源对象,用 WeakMap 记录已访问对象的引用;遇到已存在的引用直接返回缓存副本,从而切断循环引用;对数组、普通对象、Map、Set、Date、RegExp 分别构造新实例。
概念解释
- 循环引用:
obj.a = obj,递归会无限栈溢出。 - WeakMap:键为源对象,值为已拷贝副本,GC 友好。
- 特殊对象:Map/Set 需要构造新实例并递归拷贝内部值;Date/RegExp 用构造器复制。
原理流程
- 先判断基本类型与 null,直接返回。
- 查 WeakMap:若源对象已拷贝,返回缓存副本。
- 根据对象类型创建空副本,放入 WeakMap。
- 递归拷贝每个属性值,赋值到新副本。
代码 / 示例
function deepClone(source, map = new WeakMap()) {
if (source === null || typeof source !== "object") return source;
if (map.has(source)) return map.get(source);
const Ctor = source.constructor;
let copy;
if (source instanceof Date) copy = new Date(source);
else if (source instanceof RegExp) copy = new RegExp(source.source, source.flags);
else if (source instanceof Map) {
copy = new Map();
map.set(source, copy);
source.forEach((v, k) => copy.set(deepClone(k, map), deepClone(v, map)));
return copy;
} else if (source instanceof Set) {
copy = new Set();
map.set(source, copy);
source.forEach((v) => copy.add(deepClone(v, map)));
return copy;
} else {
copy = Array.isArray(source) ? [] : Object.create(Ctor.prototype);
}
map.set(source, copy);
for (const key of Reflect.ownKeys(source)) {
copy[key] = deepClone(source[key], map);
}
return copy;
}
常见误区
- 误区:用普通对象做缓存;正解:用 WeakMap,键为源对象引用,避免内存泄漏与无法 GC。
- 误区:只处理 plain object 与数组;正解:Map/Set/Date/RegExp/Promise/ArrayBuffer 等需要分别处理,否则会退化成空对象。
追问
- Q:函数怎么拷贝? A:函数通常共享引用(行为一致),深拷贝函数无意义;若需要可复制闭包则需反序列化,不推荐。
- Q:循环引用中 Map 的 key 也要拷贝吗? A:Map 的 key 也可能是对象,递归拷贝 key 才能真正解耦。
03.10.2-002 typeof 与 Object.prototype.toString 的区别
一句话结论
typeof 对基本类型与函数有效,但对 null、数组、Date、Map 等都返回 "object";Object.prototype.toString.call(x) 返回 [object Type],能区分数组、Date、Map、Set、Symbol 等内置对象。
概念解释
- typeof:基于值的类型标签,历史原因对 null 错误返回 object。
- toString:读取对象内部
[[Class]]或 Symbol.toStringTag。
原理流程
- typeof 直接返回类型标签字符串。
- toString 调用时用 call 把 this 绑定到目标,读取内部插槽。
代码 / 示例
typeof null; // "object"
typeof []; // "object"
Object.prototype.toString.call([]); // "[object Array]"
Object.prototype.toString.call(new Map()); // "[object Map]"
Object.prototype.toString.call(Symbol()); // "[object Symbol]"
常见误区
- 误区:typeof 能判断数组;正解:用 Array.isArray。
- 误区:toString 可被改写;正解:若对象定义了 Symbol.toStringTag,会影响输出,需要更严格判断时结合 instanceof。
追问
- Q:如何实现通用 type 函数? A:
Object.prototype.toString.call(x).slice(8, -1).toLowerCase()。 - Q:instanceof 与 toString 哪个更可靠? A:跨 realm(iframe/node vm)时 instanceof 失效,toString 更稳;但 toString 对自定义类只显示 Object。
03.10.2-003 浅拷贝与深拷贝的边界
一句话结论
浅拷贝只复制第一层属性,嵌套对象仍共享引用;深拷贝递归复制所有层级,新旧对象完全独立。
概念解释
- 浅拷贝:
{...obj}、Object.assign({}, obj)、Array.prototype.slice()。 - 深拷贝:递归克隆、structuredClone、lodash.cloneDeep。
原理流程
- 浅拷贝:新对象第一层是新值,第二层属性仍指向原对象。
- 深拷贝:每一层都新建容器并递归赋值。
代码 / 示例
const src = { a: 1, nested: { b: 2 } };
const shallow = { ...src };
shallow.nested.b = 99; // src.nested.b 也变 99
常见误区
- 误区:spread 等于深拷贝;正解:只对第一层有效,嵌套对象仍共享。
- 误区:数组 concat/slice 是深拷贝;正解:都是浅拷贝,元素若为对象仍共享。
追问
- Q:不可变更新如何做? A:用展开运算符更新需要修改的层级,其它层保持引用,配合结构共享。
- Q:何时该用浅拷贝? A:状态管理更新(Redux 风格),只要被修改路径上的对象新建即可。
03.10.2-004 JSON.parse(JSON.stringify) 有哪些坑
一句话结论
JSON 序列化会丢弃 undefined、函数、Symbol、Map/Set、循环引用直接报错,Date 转字符串,NaN/Infinity 转 null,正则变空对象;不能作为深拷贝通用方案。
概念解释
- undefined/function/Symbol:序列化时被忽略。
- 循环引用:直接抛 TypeError。
- Date:变成 ISO 字符串。
- Map/Set/Class 实例:变成
{}或丢失属性。
原理流程
- JSON.stringify 按规则遍历,遇到不可序列化值丢弃或报错。
- JSON.parse 反序列化时按 JSON 规范重建普通对象。
代码 / 示例
JSON.stringify({ a: undefined, fn() {}, m: new Map([[1, 2]]) });
// "{"m":{}}"
常见误区
- 误区:JSON 方法是最快的深拷贝;正解:仅适用于纯 JSON 兼容数据,遇到特殊类型就丢数据。
- 误区:循环引用报错是因为太复杂;正解:JSON 规范不支持循环引用,必须手动切断。
追问
- Q:什么场景下 JSON 深拷贝够用? A:纯接口数据、日志、缓存 payload,没有函数与 Date 时。
- Q:如何保留 Date? A:reviver 函数在 parse 时检测 ISO 字符串重建 Date。
03.10.2-005 structuredClone 支持哪些类型,不支持哪些
一句话结论
structuredClone 是浏览器与 Node 17+ 内置的结构化克隆算法,支持基本类型、普通对象、数组、Map、Set、Date、RegExp、ArrayBuffer、Blob、File、ImageData、循环引用;不支持函数、方法、Symbol、DOM 节点、Error、Function、Promise、WeakMap/WeakSet。
概念解释
- 结构化克隆:浏览器内部用于 postMessage、IndexedDB 的算法。
- 不支持:函数与 Symbol 会直接抛 DataCloneError。
原理流程
- 浏览器把对象序列化为二进制形式。
- 在新 realm 反序列化,保留引用关系。
代码 / 示例
structuredClone({ a: 1, m: new Map([[1, 2]]), cycle: null });
// 自动处理循环引用
structuredClone({ fn() {} }); // 抛 DataCloneError
常见误区
- 误区:structuredClone 能复制函数;正解:函数与 Symbol 不可克隆,需要时改用共享引用。
- 误区:它和 JSON 一样会丢数据;正解:结构化克隆保留 Map/Set/Date/循环引用,是现代首选深拷贝。
追问
- Q:postMessage 内部用什么? A:就是结构化克隆,因此传函数无法被调用。
- Q:Node 端如何用? A:Node 17 起全局提供
structuredClone,更早版本用v8.serialize。
03.10.2-006 如何正确判断数组与普通对象
一句话结论
数组用 Array.isArray(x);普通对象用 x !== null && typeof x === "object" && Object.prototype.toString.call(x) === "[object Object]",并排除 Date/Map/Set 等内置类。
概念解释
- Array.isArray:跨 realm 可靠。
- plain object:对象的原型直接是 Object.prototype,或由 Object.create(null) 创建。
原理流程
- 先排除 null 与非 object。
- 再排除数组与内置类。
- 最后检查原型链。
代码 / 示例
function isPlainObject(x) {
if (Object.prototype.toString.call(x) !== "[object Object]") return false;
const proto = Object.getPrototypeOf(x);
return proto === null || proto === Object.prototype;
}
常见误区
- 误区:typeof x === "object" 就是普通对象;正解:null、数组、Date、Map 都满足。
- 误区:
x.constructor === Object足够;正解:跨 realm 或原型被改写时不可靠。
追问
- Q:跨 realm 如何判断? A:用 toString 而非 instanceof;跨 realm 的 Array.isArray 仍可靠。
- Q:class 实例算不算 plain object? A:不算,原型不是 Object.prototype,深拷贝时需要单独处理或共享引用。
03.10.2-007 Symbol 与函数在深拷贝中的处理
一句话结论
Symbol 作为属性键时在深拷贝中通常保留(用 Reflect.ownKeys 可遍历到),但 Symbol 值本身不复制,只共享引用;函数一般共享引用,因为函数行为不应被复制,反序列化函数会丢失闭包。
概念解释
- Reflect.ownKeys:返回包括 Symbol 键在内的所有自身属性。
- 函数:在结构化克隆与 JSON 中都不支持。
原理流程
- 遍历属性时用 Reflect.ownKeys 拿到 Symbol 键。
- 函数值直接保留原引用。
- Symbol 值本身不可克隆,保持原引用。
代码 / 示例
const s = Symbol("key");
const obj = { [s]: 1, fn: () => 2 };
Reflect.ownKeys(obj); // [Symbol(key), "fn"]
常见误区
- 误区:for...in 能遍历 Symbol 键;正解:for...in 与 Object.keys 忽略 Symbol,要用 getOwnPropertySymbols 或 Reflect.ownKeys。
- 误区:函数拷贝后闭包还在;正解:除非 eval 反序列化源码,否则函数必须共享引用。
追问
- Q:为什么 lodash.cloneDeep 不复制函数? A:函数是行为描述,复制无意义;共享引用是合理默认。
- Q:Symbol 作为 Map key 如何处理? A:递归时若 key 是 Symbol 也保留引用,不复制。
03.10.2-008 如何实现 type 函数返回精确类型字符串
一句话结论
type(x) 内部用 Object.prototype.toString.call(x).slice(8, -1),并对 null 与 undefined 做特判,返回首字母大写的类型名如 "Array"、"Map"、"Date"。
概念解释
- toString 输出格式:
[object Type]。 - 边界:null 与 undefined 需要单独处理。
原理流程
- 对 null/undefined 直接返回字符串。
- 其它走 toString 切片。
代码 / 示例
function type(x) {
if (x === null) return "Null";
if (x === undefined) return "Undefined";
return Object.prototype.toString.call(x).slice(8, -1);
}
常见误区
- 误区:对 undefined 直接 toString;正解:
Object.prototype.toString.call(undefined)返回[object Undefined]其实可用,但单独判断更直观。 - 误区:自定义类会返回 Object;正解:除非定义 Symbol.toStringTag,否则用户类都显示 Object。
追问
- Q:如何识别 class 实例? A:读
x.constructor.name,可拿到类名。 - Q:Symbol.toStringTag 如何影响? A:定义后 toString 输出自定义名字,可用于库内类型识别。
待整理清单
- [ ] 深拷贝对 Promise / ArrayBuffer / SharedArrayBuffer 的处理
- [ ] 原型链拷贝与 class 实例拷贝策略
- [ ] 深拷贝性能与 Immutability 库对比
关联与延伸
- 与 03.2.1.5 拷贝与内置对象互为补充,本节聚焦手写实现与边界处理。
- structuredClone 与 lodash.cloneDeep 的取舍:前者零依赖但类型受限,后者功能全但体积大。
- 生产环境中通常选择 structuredClone 处理普通数据,复杂场景用 lodash,避免自实现深拷贝。