罗罗编程学习记录
本页内容 展开查看

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 用构造器复制。

原理流程

  1. 先判断基本类型与 null,直接返回。
  2. 查 WeakMap:若源对象已拷贝,返回缓存副本。
  3. 根据对象类型创建空副本,放入 WeakMap。
  4. 递归拷贝每个属性值,赋值到新副本。

代码 / 示例

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。

原理流程

  1. typeof 直接返回类型标签字符串。
  2. 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。

原理流程

  1. 浅拷贝:新对象第一层是新值,第二层属性仍指向原对象。
  2. 深拷贝:每一层都新建容器并递归赋值。

代码 / 示例

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 实例:变成 {} 或丢失属性。

原理流程

  1. JSON.stringify 按规则遍历,遇到不可序列化值丢弃或报错。
  2. 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。

原理流程

  1. 浏览器把对象序列化为二进制形式。
  2. 在新 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) 创建。

原理流程

  1. 先排除 null 与非 object。
  2. 再排除数组与内置类。
  3. 最后检查原型链。

代码 / 示例

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 中都不支持。

原理流程

  1. 遍历属性时用 Reflect.ownKeys 拿到 Symbol 键。
  2. 函数值直接保留原引用。
  3. 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 需要单独处理。

原理流程

  1. 对 null/undefined 直接返回字符串。
  2. 其它走 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,避免自实现深拷贝。