JS创建JSON时怎么处理Date和Function等特殊类型

作者:函数茶馆

时间:2026-11-18

浏览:524

详细讲解在 JavaScript 中创建与解析 JSON 时处理 Date、Function、undefined、RegExp 等特殊类型的方法、可运行代码示例、Type Envelope 协议设计及安全防范机制。

文章目录

JavaScript 原生提供的 JSON.stringify() 仅支持对象、数组、字符串、数字、布尔值与 null 这六种纯数据类型。当对象中包含 Date、Function、undefined、RegExp、BigInt 等特殊类型时,原生序列化机制会导致属性丢失、静默退化或抛出致命异常。解决这一问题的标准路径主要有两种:对于单纯需要保留时间精度的 Date,通过 JSON.stringify 的 replacer 参数与 JSON.parse 的 reviver 参数实现精确拦截与还原;对于包含 Function 及更多复杂类型的场景,则采用统一的“类型包装协议”(Type Envelope DTO),并在函数反序列化时严格设立沙箱边界与权限防护。

JS创建JSON时怎么处理Date和Function等特殊类型
图 0:从 JavaScript 复杂内存对象向标准 JSON 纯文本的序列化转换管道模型

一、默认行为剖析:为什么特殊类型无法直接序列化

在编写业务代码时,直接调用 JSON.stringify(data) 常常会产生意料之外的截断。这是因为 JSON 本质上是一种跨语言的纯文本数据交换规范,在设计之初就刻意剔除了与宿主语言执行环境高度绑定的概念。

原生 JSON.stringify() 在遇到各类特殊类型时的具体表现如下:

  • Date 实例:Date.prototype 原生实现了 toJSON() 方法。当 JSON.stringify() 探测到对象拥有 toJSON() 时,会自动调用它,将其转变为 UTC 格式的 ISO 8601 字符串(例如 "2026-11-17T04:07:25.000Z")。虽然时间信息保留了下来,但它变成了纯字符串;在之后执行 JSON.parse() 时,解析器只会将其当作普通字符串,无法直接调用 date.getFullYear() 或 date.getTime()。
  • Function、undefined 与 Symbol:在普通对象中,包含这类值的属性会被静默丢弃(键值对直接消失);如果它们存在于数组中,则会被统一替换为 null;如果是作为独立参数传入 JSON.stringify(),则直接返回 undefined。
  • RegExp 与 Error:两者的实例在序列化时没有任何可枚举的自有数据属性,默认会被转为空对象 {},正则表达式的规则和修饰符彻底丢失。
  • BigInt 大整数:无法被序列化,会直接抛出运行时错误 TypeError: Do not know how to serialize a BigInt,导致整个序列化流程中断。
JS创建JSON时怎么处理Date和Function等特殊类型
图 1:原生 JSON.stringify() 处理特殊类型的内部流向与最终产物差异对比

二、处理 Date 类型:精准序列化与无损还原

处理 Date 类型的核心目标是保证数据在往返(Round-trip)后依然是真正的 Date 实例,而不是失去时间计算能力的静态文本。

方法 1:利用 reviver 函数拦截还原(推荐做法)

由于 Date 在 JSON.stringify() 时默认输出符合 ISO 8601 标准的字符串,我们无需在序列化阶段做任何 hack,只需在接收端使用 JSON.parse() 的第二个参数(即 reviver 函数)进行模式匹配并重新构造实例:

// 定义 ISO 8601 时间格式匹配正则
const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;

function dateReviver(key, value) {
  // 若属性值符合 ISO 时间文本特征,重新构造为 Date 实例
  if (typeof value === 'string' && ISO_DATE_PATTERN.test(value)) {
    return new Date(value);
  }
  return value;
}

// 示例对象
const order = {
  orderId: "ORD-94921",
  createdAt: new Date("2026-11-17T12:00:00.000Z"),
  amount: 258.5
};

// 1. 序列化为标准 JSON
const jsonText = JSON.stringify(order);
console.log(jsonText);
// 输出示例: {"orderId":"ORD-94921","createdAt":"2026-11-17T12:00:00.000Z","amount":258.5}

// 2. 携带 reviver 解析并还原
const restoredOrder = JSON.parse(jsonText, dateReviver);

console.log(restoredOrder.createdAt instanceof Date); // true
console.log(restoredOrder.createdAt.toISOString());    // 正常调用 Date 原型方法
注意事项:使用正则匹配纯字符串时,若普通用户输入的文本恰好也是符合 ISO 格式的字符串(例如日志检索关键词),可能会被误转换为 Date。如果业务对数据精确度有严苛要求,应当采用下文介绍的显式类型包装协议。

三、处理 Function 类型:方案实现与安全防范

在 JavaScript 中,函数不仅仅是一段文本,它还绑定了词法作用域、上下文闭包以及对外部变量的引用。因此,必须先明确:JSON 适用于传递静态数据,而非跨网络分发动态可执行代码。

但在某些特殊场景(如前端低代码平台的自定义公式、动态组件配置、工作流节点表达式或 Web Worker 间的数据传递)中,确实需要把简单的计算函数持久化或传递。

1. 函数序列化:提取函数源码

在序列化函数时,可以调用 Function.prototype.toString() 获取函数源码。为了防止 JSON.stringify() 默认丢弃该属性,必须借助 replacer 函数显式将其转换为字符串或特定对象:

function functionReplacer(key, value) {
  if (typeof value === 'function') {
    return {
      __type: 'Function',
      __body: value.toString()
    };
  }
  return value;
}

const taskConfig = {
  taskId: 101,
  calculateTax: function(price) {
    return price * 0.13;
  }
};

const serialized = JSON.stringify(taskConfig, functionReplacer, 2);
console.log(serialized);
/* 
输出结果:
{
  "taskId": 101,
  "calculateTax": {
    "__type": "Function",
    "__body": "function(price) {\n    return price * 0.13;\n  }"
  }
}
*/

2. 函数反序列化:规避危险的 eval

反序列化函数时,严禁使用 eval()。eval() 能够在当前作用域随意执行任意代码并篡改本地作用域变量,是极其危险的攻击入口。如果必须重建函数,应使用 new Function() 构造器,并且只在严格隔离的受控作用域中执行:

function functionReviver(key, value) {
  if (value && typeof value === 'object' && value.__type === 'Function') {
    const fnBody = value.__body;
    // 使用 new Function 构建闭包隔离的执行体
    // 注意:只能还原纯函数,无法捕获原作用域中的外层闭包变量
    return new Function(`return (${fnBody})`)();
  }
  return value;
}

const restoredTask = JSON.parse(serialized, functionReviver);
console.log(typeof restoredTask.calculateTax); // "function"
console.log(restoredTask.calculateTax(100));   // 13
高危提醒:从不可信来源(如外部用户输入、未经签名的第三方 API)接收并反序列化包含代码的 JSON,等同于开启远程代码执行(RCE)后门。若仅为了根据类型执行不同逻辑,首选方案是在接收端维护静态函数查找表(Registry),JSON 中仅传递函数名称字符串(如 "handler": "calculateTax"),由接收端查表调用。

四、操作步骤:构建通用的类型可逆处理管道

为了一劳永逸地处理 Date、Function、RegExp、BigInt 以及普通对象,可以封装一套通用的序列化与反序列化工具函数。以下为构建该管道的 4 个关键操作步骤。

JS创建JSON时怎么处理Date和Function等特殊类型
图 2:实现类型可逆转换的 4 步标准操作执行闭环

完整可运行的管道代码实现

以下代码提供了一套无第三方依赖的工程化处理方案,可在现代浏览器及 Node.js 环境中直接使用:

/**
 * 通用可逆序列化管道
 */
const CustomSerializer = {
  // 步骤 1 & 2:拦截类型并封装为 Envelope 协议
  stringify(obj, indent = 0) {
    return JSON.stringify(obj, (key, value) => {
      // 处理原始上下文:通过 this[key] 获取未被 toJSON 修改的原始值
      const rawValue = this[key] !== undefined ? this[key] : value;

      if (rawValue instanceof Date) {
        return { __customType: 'Date', payload: rawValue.toISOString() };
      }
      if (typeof rawValue === 'function') {
        return { __customType: 'Function', payload: rawValue.toString() };
      }
      if (rawValue instanceof RegExp) {
        return { __customType: 'RegExp', payload: { source: rawValue.source, flags: rawValue.flags } };
      }
      if (typeof rawValue === 'bigint') {
        return { __customType: 'BigInt', payload: rawValue.toString() };
      }
      if (rawValue === undefined) {
        return { __customType: 'undefined' };
      }

      return value;
    }, indent);
  },

  // 步骤 3 & 4:反向拦截并重建对应类型的实例
  parse(jsonStr) {
    return JSON.parse(jsonStr, (key, value) => {
      if (value && typeof value === 'object' && value.__customType) {
        switch (value.__customType) {
          case 'Date':
            return new Date(value.payload);
          case 'Function':
            // 生产环境下建议在此处结合业务白名单进行合法性校验
            return new Function(`return (${value.payload})`)();
          case 'RegExp':
            return new RegExp(value.payload.source, value.payload.flags);
          case 'BigInt':
            return BigInt(value.payload);
          case 'undefined':
            return undefined;
          default:
            return value;
        }
      }
      return value;
    });
  }
};

// 运行验证示例
const mixedPayload = {
  title: "任务元数据",
  timestamp: new Date("2026-11-17T10:00:00.000Z"),
  validator: function(text) { return text.length > 0; },
  pattern: /^[A-Z0-9_-]+$/i,
  largeCounter: 9007199254740995n
};

// 序列化
const encoded = CustomSerializer.stringify(mixedPayload, 2);
// 反序列化
const decoded = CustomSerializer.parse(encoded);

console.log(decoded.timestamp instanceof Date);       // true
console.log(decoded.pattern instanceof RegExp);       // true
console.log(typeof decoded.largeCounter);             // "bigint"
console.log(decoded.validator("test"));               // true

五、架构设计:Type Envelope 协议与安全边界

当系统规模变大、涉及到跨微服务调用或前后端全栈数据流转时,零散的正则匹配不再能够满足健壮性要求。此时应当将特殊类型抽象为正式的数据传输契约,即 Type Envelope(类型信封)模式。

JS创建JSON时怎么处理Date和Function等特殊类型
图 3:Type Envelope 协议的分层架构设计与代码执行安全防护栏

在这一架构中,核心规则如下:

  1. 契约明确化:所有非常规类型均在序列化阶段被打包成包含 __customType 与 payload 的标准键值对。下游系统即使不支持对应的 JavaScript 运行时,也能清晰识别字段含义,不至于因为格式异常而报错崩溃。
  2. 职责分离:JSON 文本流始终保持符合 RFC 8259 规范的格式,网关、日志系统和代理服务器能够正常对其进行无差别缓存与转发。
  3. 安全防御纵深:在函数与动态代码的反序列化边界上,必须坚持“最小权限原则”。若只需要动态规则计算,可以使用 AST 解析库(如 jsep)解析数学表达式,彻底杜绝注入隐患。

六、选型建议与技术方案总结

在实际项目选型中,无需盲目引入复杂的自制解析器。应根据数据流转的具体场景,选用适度的解决方案:

JS创建JSON时怎么处理Date和Function等特殊类型
图 4:特殊类型序列化方案适用场景与技术选型权衡图
业务应用场景 涉及类型 推荐方案 核心优势与权衡
标准前后端 REST / GraphQL 通信 Date 采用 ISO 8601 字符串 + 接收端字段解析 符合行业标准,兼容各类语言后端;避免私有协议绑定。
同构框架数据共享 (tRPC / Next / Nuxt) Date, BigInt, RegExp, Set, Map 成熟类库(如 superjson) 全开箱即用,双向无损还原,支持所有原生容器与复杂对象。
前端轻量状态持久化 (LocalStorage) Date, undefined 自定义 replacer / reviver 管道 零第三方依赖,打包体积无增加,逻辑透明直观。
低代码 / 动态规则引擎 Function 静态命令字表 (Registry) 或 AST 表达式引擎 杜绝 eval 注入风险,确保企业级生产环境的安全合规。

总而言之,处理 JavaScript 中的特殊类型序列化时,关键在于理解 JSON 规范的设计初衷。让数据负责表达状态,由系统逻辑负责赋予行为,必要时借助 replacer 与 reviver 建立受控的转换通道,便能在保证代码健壮性的同时构筑严密的安全防线。

实用工具推荐

电子包浆

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

使用 ›
图片压缩

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

使用 ›
相关文章