JSON.parse(stringify)深拷贝的局限:无法处理Date、RegExp和undefined

作者:小括号

时间:2026-11-19

浏览:298

深入解析利用 JSON.parse(JSON.stringify(obj)) 实现深拷贝时的核心局限,剖析 Date 字符串化、RegExp 变空对象及 undefined 属性丢失的底层原因,并提供 structuredClone 与标准深拷贝方案。

文章目录
JavaScript / 前端核心技术深度剖析
分类:语言底层与避坑指南 阅读时长:约 8 分钟 技术要点:对象克隆 / 数据序列化 / 原型链
JSON.parse(stringify)深拷贝的局限:无法处理Date、RegExp和undefined

缩略图:JSON.parse(stringify) 破坏性类型转换概览

在 JavaScript 日常开发中,JSON.parse(JSON.stringify(obj)) 经常被当作实现深拷贝的“快速捷径”。然而,该技巧的成立前提是对象仅包含可被合法 JSON 表达的基本类型。一旦数据结构中存在 Date 日期对象、RegExp 正则表达式 或 undefined 属性,该方案会瞬间引发不可逆的静默数据失真——日期退化为纯字符串从而切断原型方法、正则规则被掏空为空对象 {}、undefined 属性被直接剔除。本文将逐项拆解这些致命局限的底层机理,并给出标准的解决方案。

一、一行代码深拷贝的诱惑与本质

之所以许多开发者习惯使用 JSON.parse(JSON.stringify(obj)),是因为它代码简短、无需引入外部依赖,且在纯字面量对象(例如仅包含数值、普通字符串、布尔值和嵌套对象的 POJO 结构)上表现尚可。

但从计算机语言与协议的设计本质来看,JSON 是一种独立于语言的文本交换格式,而不是 JavaScript 内存对象的持久化机制。执行 JSON.parse(JSON.stringify(obj)) 实际上经历了两个完全独立的阶段:

  1. 序列化阶段(JSON.stringify):将内存中的 JS 数据结构按照 ECMAScript 规范的 JSON 规范规约为标准 JSON 文本。任何不属于标准 JSON 规范的数据类型,都会在此阶段被强制过滤、调用自定义 toJSON 方法降级或直接剔除。
  2. 反序列化阶段(JSON.parse):将纯文本字符串重构为全新的 JS 基础对象。由于中间的纯文本已经失去了原始类型、原型链及隐藏内部插槽信息,重构出的只能是通用字面量。
JSON.parse(stringify)深拷贝的局限:无法处理Date、RegExp和undefined

图 1:JSON 序列化与反序列化各执行阶段的数据规约与类型破坏流程

正是由于这一不可调和的设计目标差异,使得 JavaScript 特有的原生对象在跨越这一管道时遭受致命损耗。接下来,我们分别分析标题中指出的三大核心陷阱。

二、局限一:Date 对象的退化与原型链断裂

当对象中包含日期实例 new Date() 时,经过 JSON 深拷贝后,该字段将永久失去 Date 实例的原型与一切时间运算方法,变成一串普通的 ISO 8601 时间格式字符串。

1. 为什么 Date 会变成字符串?

在 ECMAScript 规范中,Date.prototype 原型对象上默认挂载了一个 toJSON() 方法。当 JSON.stringify() 序列化某个对象遇到 Date 实例时,会优先调用其上的 toJSON() 方法。

而 Date.prototype.toJSON() 的内部实现等同于调用 this.toISOString(),直接返回类似 "2026-11-18T07:28:30.000Z" 的字符串。反序列化 JSON.parse() 在读取该字符串时,无法获知其原本是日期对象,只能将其原样构造为 JavaScript 原生 String。

JavaScript 运行示例:Date 属性拷贝对比Node.js / Browser Console
// 1. 构建包含 Date 的源对象
const source = {
  title: "订单详情",
  createdAt: new Date(1773905310000)
};

// 2. 使用 JSON 方式进行深拷贝
const cloned = JSON.parse(JSON.stringify(source));

// 3. 验证类型与行为差异
console.log(typeof source.createdAt);        // 输出: "object"
console.log(source.createdAt instanceof Date); // 输出: true
console.log(source.createdAt.getTime());       // 输出: 1773905310000

console.log(typeof cloned.createdAt);        // 输出: "string" (类型已退化!)
console.log(cloned.createdAt instanceof Date); // 输出: false (已非 Date 实例)

// 4. 致命后果:调用原生日期方法抛出运行时异常
try {
  cloned.createdAt.getTime();
} catch (err) {
  console.error(err.message); 
  // 输出: TypeError: cloned.createdAt.getTime is not a function
}
排查与业务隐患
在电商结算、日志时间比对、打卡统计等业务中,若将带有日期的配置或状态克隆后传递给后续函数,后续代码若直接调用 date.getFullYear() 或时间戳计算,将在生产环境直接引发 TypeError 崩溃。

三、局限二:RegExp 对象的掏空与功能归零

正则表达式字面量或 new RegExp() 实例经由 JSON.parse(JSON.stringify(obj)) 拷贝后,不仅不会保留正则表达式,还会被彻底掏空为一个没有任何属性的普通空对象 {}。

1. RegExp 为什么会变成空对象?

标准 JSON 规范中根本没有正则表达式类型。当 JSON.stringify() 遇到 RegExp 实例时,发现该对象并没有实现自定义的 toJSON(),因此会采用通用对象的遍历逻辑,即只序列化对象自身具有的可枚举属性(own enumerable properties)。

然而,正则表达式的核心参数(例如匹配规则源码 source、修饰符 flags、global、ignoreCase 等)全部封装在内部插槽或定义在 RegExp.prototype 的访问器属性中,并非实例自身的普通可枚举属性。因此,遍历结果为空,JSON.stringify(/^[a-z]+$/gi) 得到的序列化结果就是 "{}"。

JavaScript 运行示例:RegExp 属性拷贝对比Node.js / Browser Console
// 1. 包含校验规则的表单配置对象
const validator = {
  field: "username",
  pattern: /^[a-zA-Z0-9_]{4,16}$/g
};

// 2. 使用 JSON 深拷贝
const clonedValidator = JSON.parse(JSON.stringify(validator));

// 3. 输出克隆后的 pattern 属性
console.log(clonedValidator.pattern); 
// 实际输出: {} (空对象!)

// 4. 尝试进行正则验证
try {
  clonedValidator.pattern.test("admin123");
} catch (err) {
  console.error(err.message);
  // 输出: TypeError: clonedValidator.pattern.test is not a function
}

四、局限三:undefined 的悄然失踪与索引篡改

undefined 是 JavaScript 独有的基本原始值之一,用于表示变量未定义或对象属性缺失。然而在标准 JSON 体系中,仅支持 null,根本不存在 undefined。

1. 对象属性中的 undefined:键被静默丢弃

当普通对象的属性值为 undefined 时,JSON.stringify 在序列化过程中会直接将该属性忽略。反序列化后,克隆对象中将完全不存在该键名。这会导致依靠 in 操作符或 Object.prototype.hasOwnProperty 的逻辑出现不可预期的偏差。

2. 数组元素中的 undefined:被强制篡改为 null

数组是一组有序的索引集合。为了保持数组的原有长度和元素索引位置不发生错位,JSON.stringify 对数组中的 undefined 采取了折中处理——将其强制替换为 null。

JavaScript 运行示例:undefined 属性与数组处理Node.js / Browser Console
// 1. 构造含有 undefined 的对象与数组
const payload = {
  token: undefined,
  status: "active",
  tags: ["admin", undefined, "user"]
};

// 2. 检查拷贝前属性状态
console.log("token" in payload);               // 输出: true (键确实存在)
console.log(payload.tags[1] === undefined);       // 输出: true

// 3. JSON 深拷贝
const copiedPayload = JSON.parse(JSON.stringify(payload));

// 4. 检查拷贝后属性状态
console.log("token" in copiedPayload);         // 输出: false (键名被直接移除!)
console.log(Object.keys(copiedPayload));       // 输出: ["status", "tags"]

console.log(copiedPayload.tags[1]);            // 输出: null (被篡改为 null,类型改变!)
JSON.parse(stringify)深拷贝的局限:无法处理Date、RegExp和undefined

图 2:Date、RegExp 与 undefined 拷贝前后状态与内存表现对比

五、容易被忽视的连带陷阱

除了标题强调的 Date、RegExp 和 undefined 外,使用 JSON.parse(JSON.stringify(obj)) 还会触发以下严重问题:

  • 循环引用直接崩溃:若对象内部存在自我引用或环状链表(如 a.self = a),JSON.stringify 会直接抛出运行时错误 Uncaught TypeError: Converting circular structure to JSON,导致程序直接中断。
  • 函数(Function)与 Symbol 彻底蒸发:包含在对象中的成员方法会被静默丢弃;若在数组中则同样被强制转化为 null;以 Symbol 作为键名的属性会全部被忽略。
  • NaN 与 Infinity 强制变 null:特殊的数值常量 NaN、Infinity 和 -Infinity 会被一律转换为 null,导致后续数学计算结果全盘失效。
  • Map 与 Set 集合丢失:现代 ES6 的 Map 和 Set 序列化后均变为空对象 {},其内部存储的键值对全部蒸发。

六、现代 JavaScript 深拷贝的正确解法

面对上述局限,我们在现代工程开发中应当如何正确执行深拷贝?根据实际运行环境与数据类型复杂度,推荐以下三种分级方案。

JSON.parse(stringify)深拷贝的局限:无法处理Date、RegExp和undefined

图 3:现代 JavaScript 对象深拷贝技术方案决策流程

方案 1:标准原生方法 structuredClone()(最强首选)

自 Node.js 17.0.0+ 以及所有现代浏览器(Chrome 98+, Firefox 94+, Safari 15.4+)起,HTML 规范的结构化克隆算法已作为全局原生函数 structuredClone() 正式落地。

  • 优势:完美原生支持 Date、RegExp、Map、Set、ArrayBuffer 及循环引用。
  • 限制:由于其属于跨线程/跨环境数据传输算法,不支持克隆包含函数(Function)及 DOM 节点的对象(尝试克隆会抛出 DOMException: DataCloneError)。
原生代码:使用 structuredClone 正确深拷贝现代运行环境
// 定义包含复合复杂类型的对象
const original = {
  name: "系统配置",
  time: new Date(),
  rule: /^[a-z]+$/gi,
  emptyVal: undefined,
  tags: new Set(["web", "sec"])
};

// 原生结构化克隆
const copy = structuredClone(original);

// 验证:所有类型均得到完整复刻!
console.log(copy.time instanceof Date);    // 输出: true
console.log(copy.time.getTime());          // 输出正常毫秒数
console.log(copy.rule instanceof RegExp);  // 输出: true
console.log(copy.rule.test("hello"));      // 输出: true
console.log("emptyVal" in copy);           // 输出: true (键完整保留)
console.log(copy.tags instanceof Set);     // 输出: true

方案 2:工业级成熟库 lodash.cloneDeep

如果项目需要运行在低版本旧浏览器环境,或者对象中确实混合挂载了需要保持引用的函数(Function),可直接采用社区公认最成熟的 lodash.cloneDeep。

方案 3:轻量级定制递归深拷贝实现

若不希望引入庞大的外部依赖,又需要精确处理 Date、RegExp 和循环引用,可编写如下轻量安全的递归克隆函数:

针对性深拷贝实现:支持 Date, RegExp 与 WeakMap 环保护通用兼容
function deepClone(target, hash = new WeakMap()) {
  // 1. 处理原始类型及 null
  if (target === null || typeof target !== "object") {
    return target;
  }

  // 2. 精确处理 Date 实例
  if (target instanceof Date) {
    return new Date(target.getTime());
  }

  // 3. 精确处理 RegExp 实例
  if (target instanceof RegExp) {
    return new RegExp(target.source, target.flags);
  }

  // 4. 处理循环引用:通过 WeakMap 记忆已经拷贝过的对象
  if (hash.has(target)) {
    return hash.get(target);
  }

  // 5. 处理数组与普通对象
  const clone = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
  hash.set(target, clone);

  // 6. 递归遍历自身可枚举键及 Symbol 属性
  const keys = [...Object.keys(target), ...Object.getOwnPropertySymbols(target)];
  for (const key of keys) {
    clone[key] = deepClone(target[key], hash);
  }

  return clone;
}

七、总结与选型对照

JSON.parse(JSON.stringify(obj)) 绝非万能的深拷贝工具。它的本质仅是“序列化为 JSON 文本再逆向重组”,其局限根植于 JSON 规范自身的设计边界。

JSON.parse(stringify)深拷贝的局限:无法处理Date、RegExp和undefined

图 4:深拷贝各技术方案全维度特性对照矩阵

特性 / 类型 JSON 序列化拷贝 原生 structuredClone() 深拷贝推荐实践
Date 日期对象 变字符串,方法丢失 无损保留 Date 实例 涉及日期运算,严禁使用 JSON 拷贝
RegExp 正则 规则丢失,变空对象 {} 无损保留 RegExp 实例 表单校验规则对象须用标准深拷贝
undefined 属性 对象键被删 / 数组变 null 属性键及原始值保留 需保持属性键存在的配置应避免 JSON 拷贝
循环引用 抛 TypeError 导致崩溃 自动维持环状引用 复杂树形或图状结构使用 structuredClone
工程实践最终结论
对于现代前端及 Node.js 服务端项目,请全面将 JSON.parse(JSON.stringify(obj)) 替换为原生 structuredClone(obj);仅当数据百分之百确定是纯 POJO(例如刚从 HTTP API 接收的纯 JSON 响应报文)且对执行微秒级吞吐极度敏感时,方可谨慎作为临时捷径使用。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章