03.2.1.5 拷贝与内置对象
所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.2 JavaScript / 03.2.1 语言核心与对象模型
03.2.1.5-001 常见浅拷贝方式有哪些?
一句话结论
Object.assign、展开运算符 {...}、数组 concat/slice/[...arr] 都是浅拷贝:复制一层属性,嵌套对象仍共享引用。
概念解释
- 浅拷贝:一层值独立,深层引用共享。
- 只复制自身可枚举属性。
- 原型不复制。
原理流程
- 创建新容器。
- 遍历源对象自身可枚举键写入。
- 嵌套对象按引用复制。
代码 / 示例
const src = { a: 1, nested: { x: 2 } };
const c1 = Object.assign({}, src);
const c2 = { ...src };
const arr = [1, { y: 2 }];
const a1 = arr.concat();
const a2 = arr.slice();
常见误区
- 误区:展开运算符是深拷贝;正解:只浅一层。
- 误区:浅拷贝复制原型方法;正解:继承属性不复制。
追问
- Q:数组与对象浅拷贝行为一致吗? A:一致,一层独立、深层共享引用。
- Q:浅拷贝后修改嵌套对象会影响源吗? A:会,嵌套对象是同一引用。
03.2.1.5-002 如何实现深拷贝并处理循环引用?
一句话结论
递归遍历每个属性,遇到对象再拷贝;用 WeakMap 记录已拷贝对象以处理循环引用;保留原型、Date、RegExp、Map、Set 等特殊类型需单独判断。
概念解释
- 循环引用:对象间接引用自身,递归不终止。
- WeakMap 键为源对象,值为拷贝结果。
- 特殊类型按构造重建。
原理流程
- 原始值直接返回。
- WeakMap 命中则返回已拷贝副本。
- 按类型重建容器并递归复制属性。
代码 / 示例
function deepClone(obj, map = new WeakMap()) {
if (obj === null || typeof obj !== 'object') return obj;
if (map.has(obj)) return map.get(obj);
if (obj instanceof Date) return new Date(obj);
if (obj instanceof RegExp) return new RegExp(obj);
const clone = Array.isArray(obj)
? []
: Object.create(Object.getPrototypeOf(obj));
map.set(obj, clone);
for (const key of Reflect.ownKeys(obj)) {
clone[key] = deepClone(obj[key], map);
}
return clone;
}
常见误区
- 误区:递归不记录源对象也能处理循环;正解:循环引用会无限递归栈溢出。
- 误区:深拷贝默认保留原型;正解:普通
{}会丢失原型,需Object.create重建。
追问
- Q:Map/Set 怎么拷贝? A:判断实例后
new Map(old)并递归拷贝键值,Set 同理。 - Q:函数如何拷贝? A:通常共享引用,函数无可拷贝状态。
03.2.1.5-003 structuredClone 有什么能力与限制?
一句话结论
structuredClone 是内置深拷贝,支持循环引用、结构化克隆算法;但不支持拷贝函数、Symbol、原型链、DOM 节点,部分可移植对象受限。
概念解释
- 支持:对象、数组、Date、Map、Set、ArrayBuffer、类型数组、循环引用。
- 不支持:函数、Symbol、原型方法、DOM 节点、错误对象等。
- 跨上下文结构化克隆使用同一算法。
原理流程
- 调用 structuredClone 传入值。
- 结构化算法遍历并克隆可移植类型。
- 不可移植类型抛 DataCloneError。
代码 / 示例
const src = { a: 1, self: null };
src.self = src;
const copy = structuredClone(src);
copy.self === copy; // true,循环引用保留
// structuredClone(() => {}); // 抛错:函数不可克隆
常见误区
- 误区:structuredClone 能拷贝原型方法;正解:原型链不保留,拷贝出普通对象/数组。
- 误区:它支持函数序列化;正解:函数被排除,需自行处理共享引用。
追问
- Q:浏览器与 Node 支持版本? A:现代环境支持,旧版本需核实(待确认)。
- Q:与 JSON 深拷贝比优势? A:支持循环引用、Date、Map/Set、二进制,不丢类型。
03.2.1.5-004 JSON 序列化会丢失哪些内容?
一句话结论
JSON.stringify 丢弃函数、undefined、Symbol、Symbol 键;Date 转为字符串;循环引用抛错;NaN/Infinity 转为 null;不可枚举属性不序列化。
概念解释
- 仅保留 JSON 支持的数据类型。
- 函数/undefined/Symbol 在对象中被忽略,在数组中变 null。
- 反序列化后 Date 是字符串,无原型方法。
原理流程
- 遍历对象可枚举属性。
- 按 JSON 类型转换值。
- 不支持类型丢弃或转 null。
代码 / 示例
const obj = {
fn() {}, u: undefined, sym: Symbol(),
date: new Date(), nan: NaN
};
JSON.stringify(obj);
// 不含 fn/u/sym;date 为字符串;nan 为 null
常见误区
- 误区:JSON 深拷贝能保留 Date 类型;正解:parse 后是字符串,需 reviver 还原。
- 误区:循环引用 JSON 静默跳过;正解:stringify 抛 TypeError。
追问
- Q:如何序列化 BigInt? A:JSON 不支持,需转字符串或自定义 replacer。
- Q:replacer 参数怎么用? A:可为函数过滤/转换键值,或数组指定保留键。
03.2.1.5-005 拷贝 Date、RegExp、Map、Set 要注意什么?
一句话结论
这些内置对象不能用普通对象遍历复制:Date/RegExp 按构造函数重建,Map/Set 需遍历拷贝键值且深层值递归;直接展开会丢失类型与内部状态。
概念解释
- Date:
new Date(old)复制时间戳。 - RegExp:
new RegExp(old)复制源与标志。 - Map/Set:容器重建,键值/元素递归克隆。
原理流程
- 判断实例类型。
- 调用对应构造函数创建副本。
- 递归复制内部值。
代码 / 示例
function cloneMap(old) {
const m = new Map();
for (const [k, v] of old) m.set(deepClone(k), deepClone(v));
return m;
}
function cloneSet(old) {
const s = new Set();
for (const v of old) s.add(deepClone(v));
return s;
}
常见误区
- 误区:
{...map}能拷贝 Map;正解:展开得到普通对象,不是 Map 实例。 - 误区:RegExp 拷贝 lastIndex 自动保留;正解:重建后需注意 lastIndex 状态重置。
追问
- Q:ArrayBuffer 怎么拷贝? A:
new ArrayBuffer(old.byteLength)配合复制字节,或 structuredClone。 - Q:TypedArray 拷贝? A:
new TypedArray(old)复制底层视图。
03.2.1.5-006 数组方法如何区分变异与不可变?
一句话结论
变异方法直接修改原数组:push/pop/shift/unshift/splice/sort/reverse/fill/copyWithin;不可变方法返回新数组:map/filter/concat/slice/flat/flatMap 与展开。
概念解释
- 变异:原数组引用被改动。
- 不可变:返回新数组,原数组不变。
- 排序/反转在状态更新中应先拷贝。
原理流程
- 识别方法是否返回新数组。
- 状态管理中优先不可变方法。
- 必须变异时先拷贝副本。
代码 / 示例
const arr = [3, 1, 2];
const sorted = [...arr].sort((a, b) => a - b); // 拷贝后排序
const doubled = arr.map(x => x * 2); // 不可变
arr.push(4); // 变异原数组
常见误区
- 误区:sort 返回排序后的新数组;正解:sort 原地变异,返回原数组引用。
- 误区:filter 会修改原数组;正解:返回过滤后的新数组。
追问
- Q:React/Vue 状态更新为什么强调不可变? A:新引用触发状态变更检测,避免直接改原状态导致视图不更新。
- Q:splice 与 slice 区别? A:splice 变异删除/插入,slice 截取返回新数组。
03.2.1.5-007 map、filter、reduce、flat 各自做什么?
一句话结论
map 一一映射新数组;filter 按条件过滤;reduce 累加归约为单值;flat 按深度拍平嵌套数组;均不修改原数组。
概念解释
- map:返回等长新数组。
- filter:返回满足条件子集。
- reduce:初始值 + 回调累积。
- flat:默认一层,参数指定深度。
原理流程
- 遍历数组元素。
- 按方法规则转换/筛选/累积。
- 返回结果数组或累积值。
代码 / 示例
const nums = [1, 2, 3, [4, [5]]];
nums.map(x => x * 2); // [2,4,6,[4,[5]]]
nums.filter(x => x > 1); // [2,3,[4,[5]]]
nums.reduce((s, x) => s + (typeof x === 'number' ? x : 0), 0);
nums.flat(2); // [1,2,3,4,5]
常见误区
- 误区:reduce 只能求和;正解:可归约为对象、数组、分组等任意值。
- 误区:flat 默认拍平所有层级;正解:默认一层,需传深度参数。
追问
- Q:flatMap 与 map+flat 区别? A:flatMap 先 map 再拍平一层,等价链式组合。
- Q:reduce 初始值缺失有什么风险? A:空数组无初始值抛错,首元素作为初始值时类型可能不一致。
03.2.1.5-008 查找元素用 find、indexOf、includes 还是 Map?
一句话结论
按值严格匹配用 includes;找索引用 indexOf;找元素对象用 find;按键快速查找用 Map;includes 对 NaN 可命中,indexOf 不能。
概念解释
- find:返回第一个匹配元素或 undefined。
- indexOf:返回索引,-1 未找到,SameValueZero 但不匹配 NaN。
- includes:SameValueZero,可匹配 NaN。
- Map:键查找 O(1) 级。
原理流程
- 明确查找目标是值、索引还是对象。
- 选择对应方法。
- 大集合按键索引用 Map。
代码 / 示例
const arr = [1, NaN, 3];
arr.includes(NaN); // true
arr.indexOf(NaN); // -1
arr.find(x => x > 2); // 3
const map = new Map([["id", 1]]);
map.get("id"); // 1
常见误区
- 误区:indexOf 能找 NaN;正解:NaN 不等于自身,indexOf 返回 -1。
- 误区:find 找不到返回 -1;正解:返回 undefined。
追问
- Q:findIndex 与 find 区别? A:返回索引还是元素对象。
- Q:对象数组按键去重用什么? A:Map 记录已见键,比数组 indexOf 高效。
03.2.1.5-009 Map 与 Object 如何选择?
一句话结论
Map 按键插入顺序遍历、键可为任意类型、size 易得、迭代器原生支持;Object 键为字符串/Symbol,适合固定结构与 JSON 序列化;动态键集合优先 Map。
概念解释
- Map:键类型不限,size 属性,可直接迭代。
- Object:原型链属性干扰,键转字符串。
- 序列化:Object 可直接 JSON,Map 需转换。
原理流程
- 判断键是否动态、类型是否多样。
- 动态/非字符串键选 Map。
- 固定结构、需 JSON 输出选 Object。
代码 / 示例
const map = new Map();
const key = { id: 1 };
map.set(key, "value");
map.size; // 1
map.get(key); // "value"
常见误区
- 误区:Object 性能一定差;正解:小对象固定键场景 Object 足够,Map 优势在动态键与类型。
- 误区:Map 键会转字符串;正解:Map 保留键类型。
追问
- Q:Map 如何转对象? A:
Object.fromEntries(map),键需可序列化为字符串。 - Q:Object 有 size 吗? A:没有,用
Object.keys(obj).length。
03.2.1.5-010 Set 如何去重?WeakSet 有什么特点?
一句话结论
Set 存储唯一值,自动去重(SameValueZero);WeakSet 键为弱引用对象,不阻止垃圾回收,不可遍历,适合临时标记对象。
概念解释
- Set:值唯一,可迭代,size 可得。
- WeakSet:只存对象,弱引用,无 size/迭代方法。
- 去重:数组转 Set 再转回数组。
原理流程
- 元素加入 Set 时按唯一性判断。
- 已存在则不重复添加。
- WeakSet 键对象无其他引用时可被回收。
代码 / 示例
const arr = [1, 1, 2, 3, 3];
const unique = [...new Set(arr)]; // [1,2,3]
const ws = new WeakSet();
const obj = {};
ws.add(obj);
常见误区
- 误区:Set 去重对对象按值比较;正解:对象按引用唯一性,两个字面量对象不相等。
- 误区:WeakSet 可以遍历;正解:不可迭代、无 size,防止弱引用被遍历保持。
追问
- Q:Set 与数组 includes 去重性能? A:Set 查找基于哈希,大集合更快。
- Q:WeakSet 用途? A:标记对象是否已处理、临时关联状态,不影响对象回收。
03.2.1.5-011 WeakMap 为什么能帮助内存回收?
一句话结论
WeakMap 键是弱引用:键对象没有其他强引用时,条目可被 GC 回收,不会像普通 Map 那样长期驻留;适合缓存、对象元数据关联。
概念解释
- 键必须是对象。
- 弱引用不阻止回收。
- 不可遍历,无 size。
原理流程
- 对象作为键存入 WeakMap。
- 对象其他引用消失。
- GC 回收对象,对应条目一并清除。
代码 / 示例
const cache = new WeakMap();
function load(obj) {
if (!cache.has(obj)) cache.set(obj, compute(obj));
return cache.get(obj);
}
常见误区
- 误区:WeakMap 值也是弱引用;正解:只键弱引用,值仍被键条目引用。
- 误区:WeakMap 键可以用原始值;正解:键必须对象。
追问
- Q:深拷贝为什么用 WeakMap 记录源对象? A:既防循环引用,又不阻止源对象回收。
- Q:普通 Map 缓存无界有什么风险? A:键对象长期驻留内存,形成泄漏。
03.2.1.5-012 JSON.parse/stringify 的 replacer 与 reviver 怎么用?
一句话结论
stringify 的 replacer 可函数过滤转换或数组指定键;parse 的 reviver 在还原每个值时回调,可把字符串日期还原为 Date 对象。
概念解释
- replacer:序列化前处理键值。
- reviver:反序列化后逐值转换。
- 二者都接收 key 与 value。
原理流程
- 序列化遍历调用 replacer。
- 生成 JSON 字符串。
- 解析时 reviver 逐层还原值。
代码 / 示例
const obj = { d: new Date("2026-01-01"), secret: 1 };
const text = JSON.stringify(obj, (k, v) => k === "secret" ? undefined : v);
const back = JSON.parse(text, (k, v) =>
k === "d" ? new Date(v) : v
);
常见误区
- 误区:replacer 返回 undefined 会保留键;正解:返回 undefined 该键被丢弃。
- 误区:reviver 只在根值调用;正解:每个嵌套值都会经过回调。
追问
- Q:JSON 循环引用怎么序列化? A:replacer 中处理引用或自定义结构,直接 stringify 抛错。
- Q:数组作为 replacer 参数? A:数组列出允许序列化的键名。
03.2.1.5-013 Date 对象常用方法与时区注意什么?
一句话结论
Date 内部存时间戳(毫秒数),方法分本地时区与 UTC 两组;解析字符串存在兼容性差异,推荐用时间戳或数值参数构造,展示按时区格式化。
概念解释
- 时间戳:
getTime()/Date.now()。 - 本地方法:
getFullYear/getMonth;UTC 方法带UTC。 - 字符串解析跨浏览器不一致。
原理流程
- 构造 Date(时间戳/数值/字符串)。
- 内部记录 UTC 时间戳。
- 按本地或 UTC 方法读取字段。
代码 / 示例
const now = Date.now();
const d = new Date(2026, 0, 18); // 本地时区,月从 0 开始
d.getTime(); // 毫秒时间戳
d.toISOString(); // UTC 字符串
常见误区
- 误区:
new Date("2026-01-18")各浏览器解析一致;正解:日期字符串解析有差异,建议数值参数。 - 误区:月份从 1 开始;正解:月参数 0–11。
追问
- Q:前后端时间传输用什么? A:ISO 字符串或时间戳,避免时区与格式歧义。
- Q:日期格式化用什么 API? A:
Intl.DateTimeFormat按 locale 与时区格式化。
03.2.1.5-014 RegExp 的 exec/test 与 lastIndex 有什么陷阱?
一句话结论
test/exec 配合全局/粘性标志时会更新 lastIndex,下次匹配从上次位置继续;复用同一正则实例可能导致结果交错,非全局正则 lastIndex 不推进。
概念解释
- 全局
g:匹配多个结果,lastIndex 推进。 - 粘性
y:从 lastIndex 位置匹配。 - exec 返回匹配数组,test 只返回布尔。
原理流程
- 正则带 g/y 标志。
- 匹配后 lastIndex 移到匹配末尾。
- 下次调用从新位置继续,复用实例需重置 lastIndex。
代码 / 示例
const re = /\d+/g;
re.test("12 34"); // true,lastIndex = 2
re.test("12 34"); // true,lastIndex = 5
re.lastIndex = 0; // 复用前重置
const m = /(\w+)/.exec("hello");
m[1]; // "hello"
常见误区
- 误区:全局正则每次 test 都从头匹配;正解:lastIndex 持续推进,可能隔次命中。
- 误区:test 返回匹配内容;正解:返回布尔,内容用 exec。
追问
- Q:如何取所有匹配? A:循环 exec 直到 null,或
str.match(re)(g 标志返回数组)。 - Q:lastIndex 可以手动设置吗? A:可以,重置为 0 从头匹配。
03.2.1.5-015 如何判断两个值是否相等?
一句话结论
原始值用 ===;对象按引用比较;Object.is 处理 NaN 与 ±0 特例;深比较需递归比较属性,不能用 == 或 JSON 字符串比较替代。
概念解释
- SameValue:Object.is,NaN 相等、+0/-0 不等。
- SameValueZero:includes/Map/Set,NaN 相等、+0/-0 相等。
- 深比较:递归类型与属性。
原理流程
- 类型不同返回 false。
- 原始值按 Object.is 比较。
- 对象引用相同为 true,否则递归比较键值。
代码 / 示例
Object.is(NaN, NaN); // true
Object.is(0, -0); // false
NaN === NaN; // false
function deepEqual(a, b) {
if (Object.is(a, b)) return true;
if (typeof a !== 'object' || a === null || b === null) return false;
const ak = Object.keys(a), bk = Object.keys(b);
if (ak.length !== bk.length) return false;
return ak.every(k => deepEqual(a[k], b[k]));
}
常见误区
- 误区:JSON.stringify 相等对象就相等;正解:键顺序、undefined、类型差异会误判。
- 误区:== 可用于深比较;正解:隐式转换导致错误相等。
追问
- Q:数组顺序影响深比较吗? A:按顺序逐元素比较,顺序不同不相等。
- Q:日期对象怎么比较? A:比较时间戳
a.getTime() === b.getTime()。
03.2.1.5-016 对象合并与嵌套合并如何实现?
一句话结论
Object.assign/展开是浅合并,同名后者覆盖前者;嵌套对象会整体替换而非深合并;需要嵌套合并时递归遍历源对象属性逐层赋值。
概念解释
- 浅合并:一层覆盖,嵌套替换。
- 深合并:嵌套对象递归合并。
- 合并不修改源对象时先建空目标。
原理流程
- 浅合并直接复制一层键值。
- 深合并判断值是否对象,递归合并。
- 保留数组/特殊类型判断。
代码 / 示例
// 浅合并
const merged = { ...a, ...b };
// 嵌套合并
function deepMerge(target, ...sources) {
for (const src of sources) {
for (const [k, v] of Object.entries(src)) {
if (v && typeof v === 'object' && !Array.isArray(v)) {
target[k] = deepMerge(target[k] ?? {}, v);
} else {
target[k] = v;
}
}
}
return target;
}
常见误区
- 误区:展开运算符会深合并嵌套;正解:嵌套对象整体覆盖。
- 误区:合并会修改第一个源对象;正解:assign 第一个参数是目标,传入新对象才不改源。
追问
- Q:数组在深合并中怎么处理? A:通常整体替换,按业务决定是否按索引合并。
- Q:默认值合并怎么写? A:先放默认对象,再覆盖用户配置。
03.2.1.5-017 Object.freeze 冻结的是什么层级?
一句话结论
Object.freeze 浅冻结:顶层属性不可增删改,嵌套对象仍可修改;深度冻结需递归冻结每层对象。
概念解释
- 冻结:属性不可写、不可配置、不可扩展。
- 浅冻结只作用一层。
Object.isFrozen检查冻结状态。
原理流程
- 冻结目标顶层属性。
- 嵌套对象引用未冻结。
- 深冻结递归遍历对象属性。
代码 / 示例
const cfg = Object.freeze({ theme: { mode: "light" } });
// cfg.theme = {}; // 严格模式报错
cfg.theme.mode = "dark"; // 嵌套仍可改
function deepFreeze(obj) {
Object.freeze(obj);
for (const v of Object.values(obj)) {
if (v && typeof v === 'object') deepFreeze(v);
}
return obj;
}
常见误区
- 误区:freeze 后整个对象图不可变;正解:只冻结顶层。
- 误区:冻结数组无意义;正解:数组同样可冻结,元素不可改。
追问
- Q:冻结与 const 区别? A:const 绑定不可重赋值,对象属性仍可变;freeze 限制属性修改。
- Q:冻结对象可以扩展属性吗? A:不可,严格模式添加属性报错。
03.2.1.5-018 内置对象类型判断的工具函数如何汇总?
一句话结论
原始类型用 typeof,null 单独判断,数组用 Array.isArray,内置对象用 toString 标签;组合成 getType 工具,覆盖主要内置类型判断场景。
概念解释
- typeof:原始类型与函数。
- toString:内置对象标签。
- 专用 API:Array.isArray、Number.isNaN 等。
原理流程
- 先判 null/undefined。
- typeof 识别原始与函数。
- 对象走 toString 标签解析。
代码 / 示例
function getType(v) {
if (v === null) return "null";
if (v === undefined) return "undefined";
if (Array.isArray(v)) return "array";
const t = typeof v;
if (t !== "object") return t;
return Object.prototype.toString.call(v).slice(8, -1).toLowerCase();
}
// getType(new Map()) -> "map"
// getType(/x/) -> "regexp"
// getType(1n) -> "bigint"
常见误区
- 误区:一个 typeof 搞定所有判断;正解:对象子类型必须专用 API 或 toString。
- 误区:类型工具返回中文;正解:返回稳定英文标签,展示层再映射。
追问
- Q:自定义类如何识别? A:
v instanceof MyClass或读取v.constructor.name,跨 realm 注意引用问题。 - Q:如何判断普通对象? A:排除数组/日期/正则等,原型为 Object.prototype 或 null。