zod

Zod：TypeScript 优先的模式验证

概述

Zod 是一个 TypeScript 优先的验证库，开发者可以使用它定义模式，在运行时验证数据，同时自动推断静态 TypeScript 类型。Zod 没有任何依赖，核心体积小巧（压缩后约为 5 kb；zod/mini 约为 1.9 kb），并提供不可变、可组合的验证能力和全面的错误处理。

安装

bun add zod
# or
npm install zod
# or
pnpm add zod
# or
yarn add zod

要求：

• TypeScript v5.5+，并在 tsconfig.json 中设置 "strict": true
• Zod 4.x（推荐使用 4.4.x；z.codec() 要求 4.1+）

重要提示：本文档介绍 Zod 4.x 的功能。以下 API 要求使用 Zod 4，在 Zod 3.x 中不可用：

• z.codec() - 双向转换
• z.iso.date()、z.iso.time()、z.iso.datetime()、z.iso.duration() - ISO 格式验证器
• z.toJSONSchema() - JSON Schema 生成
• z.treeifyError()、z.prettifyError()、z.flattenError() - 新的错误格式化辅助函数
• .meta() - 增强的元数据（Zod 3.x 仅有 .describe()）
• 统一的 error 参数 - 取代 message、invalid_type_error、required_error、errorMap
• .check() - 低级别的多问题验证（可组合 z.minLength(3) 等检查工厂函数）
• z.file()、z.json()、z.stringbool()、z.xor()、z.templateLiteral() - 新的模式类型
• z.exactOptional()、.prefault()、.safeExtend()、z.fromJSONSchema() - 新的实用工具

有关 Zod 3.x 兼容性或迁移指南，请参阅 https://zod.dev

导入路径（均包含在 zod 包中）：

• import { z } from "zod" — 标准导入（自 4.0 起为 v4）
• import { z } from "zod/v4" — 供同时支持 v3（3.25+）和 v4 用户的库固定版本
• import { z } from "zod/mini" — 函数式、可进行树摇优化的 API（约 1.9 kb；通过 .check(z.minLength(3)) 进行检查）
• import * as core from "zod/v4/core" — 面向库作者、以 $ 为前缀的底层内部 API

从 Zod v3 迁移到 v4

加载 references/migration-guide.md，查看完整的 v3 到 v4 迁移文档。

快速摘要

Zod v4 引入了破坏性变更，以提升性能：

• 错误自定义：使用统一的 error 参数（取代 message、invalid_type_error、required_error）
• 数字验证：更加严格——拒绝 Infinity 和不安全整数
• 字符串格式：优先使用顶层函数（例如 z.email()，而非 z.string().email()；方法形式仍可使用，但已弃用）
• 对象默认值：即使在可选字段中也会应用
• 已弃用的 API：使用 .extend()（而非 .merge()）、z.treeifyError()（而非 error.format()）
• 函数验证：使用 .implement() 方法
• UUID 验证：更严格地遵循 RFC 9562/4122

→ 加载 references/migration-guide.md 查看： 完整的破坏性变更、迁移检查清单、渐进式迁移策略、回滚说明

核心概念

基本用法模式

import { z } from "zod";

// Define schema
const UserSchema = z.object({
  username: z.string(),
  age: z.number().int().positive(),
  email: z.email(),
});

// Infer TypeScript type
type User = z.infer<typeof UserSchema>;

// Validate data (throws on error)
const user = UserSchema.parse(data);

// Validate data (returns result object)
const result = UserSchema.safeParse(data);
if (result.success) {
  console.log(result.data); // Typed!
} else {
  console.error(result.error); // ZodError
}

解析方法

根据错误处理需求选择合适的解析方法：

• .parse(data) - 输入无效时抛出 ZodError；成功时返回类型明确的数据
• .safeParse(data) - 返回 { success: true, data } 或 { success: false, error }（不会抛出异常）
• .parseAsync(data) - 用于带有异步细化或转换的模式
• .safeParseAsync(data) - 不会抛出异常的异步版本

最佳实践：使用 .safeParse() 避免编写 try-catch 代码块，并利用判别联合。

基本类型

字符串

z.string()                    // Basic string
z.string().min(5)            // Minimum length
z.string().max(100)          // Maximum length
z.string().length(10)        // Exact length
z.email()                    // Email validation (top-level in v4)
z.url()                      // URL validation (top-level in v4)
z.uuid()                     // UUID (RFC 9562; use z.guid() for permissive)
z.uuidv4()                   // Version-specific UUIDs (also z.uuidv7)
z.httpUrl()                  // http/https URLs only (rejects ftp:// etc.)
z.e164()                     // Phone numbers (E.164 format)
z.string().regex(/^\d+$/)    // Custom pattern
z.string().startsWith("pre") // Prefix check
z.string().endsWith("suf")   // Suffix check
z.string().trim()            // Auto-trim whitespace
z.string().toLowerCase()     // Auto-lowercase
z.string().toUpperCase()     // Auto-uppercase

// ISO formats (Zod 4+)
z.iso.date()                 // YYYY-MM-DD
z.iso.time()                 // HH:MM:SS
z.iso.datetime()             // ISO 8601 datetime
z.iso.duration()             // ISO 8601 duration

// Network formats
z.ipv4()                     // IPv4 address
z.ipv6()                     // IPv6 address
z.cidrv4()                   // IPv4 CIDR notation
z.cidrv6()                   // IPv6 CIDR notation

// Other formats
z.jwt()                      // JWT token
z.nanoid()                   // Nanoid
z.cuid()                     // CUID
z.cuid2()                    // CUID2
z.ulid()                     // ULID
z.base64()                   // Base64 encoded
z.hex()                      // Hexadecimal
z.hash("sha256")             // Hash of algorithm-specific length
z.guid()                     // Permissive UUID/GUID (non-RFC)
z.hostname()                 // Hostname
z.mac()                      // MAC address
z.uuid({ version: "v4" })    // UUID with version constraint
z.email({ pattern: z.regexes.email }) // Email with explicit pattern

数字

z.number()                   // Basic number
z.number().int()             // Integer only
z.number().positive()        // > 0
z.number().nonnegative()     // >= 0
z.number().negative()        // < 0
z.number().nonpositive()     // <= 0
z.number().min(0)            // Minimum value
z.number().max(100)          // Maximum value
z.number().gt(0)             // Greater than
z.number().gte(0)            // Greater than or equal
z.number().lt(100)           // Less than
z.number().lte(100)          // Less than or equal
z.number().multipleOf(5)     // Must be multiple of 5
z.int()                      // Shorthand for z.number().int()
z.int32()                    // 32-bit integer (also z.uint32, z.int64, z.uint64)
z.float32()                  // 32-bit float (also z.float64)
z.nan()                      // NaN value

强制转换（类型转换）

z.coerce.string()            // Convert to string
z.coerce.number()            // Convert to number
z.coerce.boolean()           // Convert to boolean
z.coerce.bigint()            // Convert to bigint
z.coerce.date()              // Convert to Date

// Example: Parse query parameters
const QuerySchema = z.object({
  page: z.coerce.number().int().positive(),
  limit: z.coerce.number().int().max(100).default(10),
});

// "?page=5&limit=20" -> { page: 5, limit: 20 }

其他基本类型

z.boolean()                  // Boolean
z.date()                     // Date object
z.date().min(new Date("2020-01-01"))
z.date().max(new Date("2030-12-31"))
z.bigint()                   // BigInt
z.symbol()                   // Symbol
z.null()                     // Null
z.undefined()                // Undefined
z.void()                     // Void (undefined)

// File validation (v4) — sizes are bytes
z.file().min(1).max(5 * 1024 * 1024).mime(["image/png"])

// JSON-representable values (v4) — validates the VALUE is JSON-serializable
// (recursive union of string | number | boolean | null | array | record)
z.json()

// Env-style boolean coercion: "true"/"yes"/"1" → true (v4)
z.stringbool({ truthy: ["true", "yes", "1"], falsy: ["false", "no", "0"] })

复杂类型

对象

const PersonSchema = z.object({
  name: z.string(),
  age: z.number(),
  address: z.object({
    street: z.string(),
    city: z.string(),
    country: z.string(),
  }),
});

type Person = z.infer<typeof PersonSchema>;

// Object methods
PersonSchema.shape                 // Access shape
PersonSchema.keyof()              // Get union of keys
PersonSchema.extend({ role: z.string() })  // Add fields
PersonSchema.safeExtend({ role: z.string() }) // Type-safe extend (inherits refinements)
PersonSchema.pick({ name: true }) // Pick specific fields
PersonSchema.omit({ age: true })  // Omit fields
PersonSchema.partial()            // Make all fields optional
PersonSchema.partial({ age: true }) // Make specific fields optional
PersonSchema.required()           // Make all fields required

// NOTE: .deepPartial() was REMOVED in v4 — build recursive partials manually
// (top-level z.deepPartial() landed post-4.4.3 and is not yet stable)

// Strict vs loose objects
z.strictObject({ ... })           // No extra keys allowed (throws)
z.object({ ... })                 // Strips extra keys (default)
z.looseObject({ ... })            // Allows extra keys
z.object({ ... }).catchall(z.number()) // Validate (and keep) unknown keys

数组

z.array(z.string())              // String array
z.array(z.number()).min(1)       // At least 1 element
z.array(z.number()).max(10)      // At most 10 elements
z.array(z.number()).length(5)    // Exactly 5 elements
z.array(z.number()).nonempty()   // At least 1 element

// Nested arrays
z.array(z.array(z.number()))     // number[][]

元组

z.tuple([z.string(), z.number()]) // [string, number]
z.tuple([z.string(), z.number()]).rest(z.boolean()) // [string, number, ...boolean[]]

枚举和字面量

// Enum
const RoleEnum = z.enum(["admin", "user", "guest"]);
type Role = z.infer<typeof RoleEnum>; // "admin" | "user" | "guest"

// Literal values
z.literal("exact_value")
z.literal(42)
z.literal(true)

// Native TypeScript enum
enum Fruits {
  Apple,
  Banana,
}
z.nativeEnum(Fruits)

// Enum methods
RoleEnum.enum.admin              // "admin"
RoleEnum.exclude(["guest"])      // Exclude values
RoleEnum.extract(["admin", "user"]) // Include only

联合类型

// Basic union
z.union([z.string(), z.number()])

// Discriminated union (better performance & type inference)
const ResponseSchema = z.discriminatedUnion("status", [
  z.object({ status: z.literal("success"), data: z.any() }),
  z.object({ status: z.literal("error"), message: z.string() }),
]);

type Response = z.infer<typeof ResponseSchema>;
// { status: "success", data: any } | { status: "error", message: string }

// Exclusive union (v4): must match exactly ONE branch
z.xor([z.object({ a: z.string() }), z.object({ b: z.number() })])

交叉类型

const BaseSchema = z.object({ id: z.string() });
const ExtendedSchema = z.object({ name: z.string() });

const Combined = z.intersection(BaseSchema, ExtendedSchema);
// Equivalent to: z.object({ id: z.string(), name: z.string() })

记录和映射

// Record: object with typed keys and values (BOTH args required in v4)
z.record(z.string(), z.number())  // { [key: string]: number }
z.record(z.enum(["a", "b"]), z.string()) // Exhaustive: both keys REQUIRED

// Partial record (enum keys optional)
z.partialRecord(z.enum(["a", "b"]), z.string())

// Map
z.map(z.string(), z.number())    // Map<string, number>
z.set(z.string())                // Set<string>

高级模式

加载 references/advanced-patterns.md，查看完整的高级验证和转换模式。

快速参考

细化（自定义验证）：

z.string().refine((val) => val.length >= 8, "Too short");
z.object({ password, confirmPassword }).superRefine((data, ctx) => { /* ... */ });

转换（修改数据）：

z.string().transform((val) => val.trim());
z.string().pipe(z.coerce.number());
z.preprocess((v) => (typeof v === "string" ? v.trim() : v), z.string()); // Transform BEFORE parsing
z.custom<string>((v) => typeof v === "string", { error: "Not a string" }); // Fully custom schema

多问题验证（.check()，v4）：

z.string().check(z.minLength(3), z.startsWith("a")); // Compose check factories
z.string().check((payload) => {
  if (payload.value === "forbidden") {
    payload.issues.push({ code: "custom", message: "Not allowed", input: payload.value });
  }
});

模板字面量（v4）：

const UserRole = z.templateLiteral(["role-", z.string()]); // "role-admin", "role-editor", ...

编解码器（双向转换——v4.1 新增）：

const DateCodec = z.codec(
  z.iso.datetime(),
  z.date(),
  {
    decode: (str) => new Date(str),
    encode: (date) => date.toISOString(),
  }
);

递归类型：

const CategorySchema: z.ZodType<Category> = z.lazy(() =>
  z.object({ name: z.string(), subcategories: z.array(CategorySchema) })
);

可选／可空：

z.string().optional()            // string | undefined
z.string().nullable()            // string | null
z.string().default("default")    // Provides default if undefined

只读与品牌：

z.object({ ... }).readonly()     // Readonly properties
z.string().brand<"UserId">()     // Nominal typing

→ 加载 references/advanced-patterns.md，了解： 完整的细化模式、异步验证、编解码器示例、可组合架构、条件验证、性能优化

错误处理

加载 references/error-handling.md，查看完整的错误格式化和自定义指南。

快速参考

错误格式化方法：

// For forms
const { fieldErrors } = z.flattenError(error);

// For nested data
const tree = z.treeifyError(error);
const nameError = tree.properties?.user?.properties?.name?.errors?.[0];

// For debugging
console.log(z.prettifyError(error));

自定义错误消息（三个级别）：

// 1. Schema-level (highest priority)
z.string({ error: "Custom message" });
z.string().min(5, "Too short");

// 2. Per-parse level
schema.parse(data, { error: (issue) => "..." });

// 3. Global level
z.config({ customError: (issue) => "..." });

本地化（40 多种语言）：

z.config(z.locales.es());  // Spanish
z.config(z.locales.fr());  // French

→ 加载 references/error-handling.md，了解： 完整的错误格式化示例、自定义错误模式、本地化设置、错误代码参考

类型推断

加载 references/type-inference.md，查看完整的类型推断和元数据文档。

快速参考

基本类型推断：

const UserSchema = z.object({ name: z.string() });
type User = z.infer<typeof UserSchema>; // { name: string }

输入与输出（用于转换）：

const TransformSchema = z.string().transform((s) => s.length);
type Input = z.input<typeof TransformSchema>;   // string
type Output = z.output<typeof TransformSchema>; // number

JSON Schema 转换：

const jsonSchema = z.toJSONSchema(UserSchema, {
  target: "openapi-3.0",
  // .meta() data from the global registry is included by default
});

元数据：

// Add metadata
const EmailSchema = z.email().meta({
  title: "Email Address",
  description: "User's email address",
});

// Create custom registry
const formRegistry = z.registry<FormFieldMeta>();

→ 加载 references/type-inference.md，了解： 完整的类型推断模式、JSON Schema 选项、元数据系统、自定义注册表、品牌类型

函数

使用 v4 工厂函数签名验证函数的输入和输出：

const AddFunction = z.function({
  input: [z.number(), z.number()], // Arguments
  output: z.number(),              // Return type
});

// Implement typed function
const add = AddFunction.implement((a, b) => {
  return a + b; // Type-checked!
});

// Async functions
const FetchFunction = z.function({
  input: [z.string()],
  output: z.object({ data: z.any() }),
});

const fetchJson = FetchFunction.implementAsync(async (url) => {
  const response = await fetch(url);
  return response.json();
});

注意：v3 的链式写法（z.function().args(...).returns(...)）已在 v4 中移除。

常见模式

环境变量

const EnvSchema = z.object({
  NODE_ENV: z.enum(["development", "production", "test"]),
  DATABASE_URL: z.url(),
  PORT: z.coerce.number().int().positive().default(3000),
  API_KEY: z.string().min(32),
});

// Validate on startup
const env = EnvSchema.parse(process.env);

// Now use typed env
console.log(env.PORT); // number

API 请求验证

const CreateUserRequest = z.object({
  username: z.string().min(3).max(20),
  email: z.email(),
  password: z.string().min(8),
  age: z.number().int().positive().optional(),
});

// Express example
app.post("/users", async (req, res) => {
  const result = CreateUserRequest.safeParse(req.body);

  if (!result.success) {
    return res.status(400).json({
      errors: z.flattenError(result.error).fieldErrors,
    });
  }

  const user = await createUser(result.data);
  res.json(user);
});

表单验证

const FormSchema = z.object({
  firstName: z.string().min(1, "First name required"),
  lastName: z.string().min(1, "Last name required"),
  email: z.email({ error: "Invalid email" }),
  age: z.coerce.number().int().min(18, "Must be 18+"),
  agreeToTerms: z.literal(true, {
    error: () => "Must accept terms",
  }),
});

type FormData = z.infer<typeof FormSchema>;

部分更新

const UserSchema = z.object({
  id: z.string(),
  name: z.string(),
  email: z.email(),
});

// For PATCH requests: make everything optional except id
const UpdateUserSchema = UserSchema.partial().required({ id: true });

type UpdateUser = z.infer<typeof UpdateUserSchema>;
// { id: string; name?: string; email?: string }

可组合架构

// Base schemas
const TimestampSchema = z.object({
  createdAt: z.date(),
  updatedAt: z.date(),
});

const AuthorSchema = z.object({
  authorId: z.string(),
  authorName: z.string(),
});

// Compose into larger schemas (.merge() is deprecated — use .extend with .shape)
const PostSchema = z.object({
  id: z.string(),
  title: z.string(),
  content: z.string(),
}).extend(TimestampSchema.shape).extend(AuthorSchema.shape);

生态集成

加载 references/ecosystem-integrations.md，查看完整的框架和工具集成指南。

快速参考

ESLint 插件：

• eslint-plugin-zod-x - 强制执行最佳实践
• eslint-plugin-import-zod - 强制执行导入风格

框架集成：

• tRPC - 端到端类型安全 API
• React Hook Form - 表单验证（参见 react-hook-form-zod 技能）
• Prisma - 根据数据库模型生成 Zod
• NestJS - DTO 和验证管道

代码生成：

• orval - OpenAPI → Zod
• Hey API - OpenAPI 转 TypeScript + Zod
• kubb - 带代码生成的 API 工具包

→ 加载 references/ecosystem-integrations.md，了解： 设置说明、集成示例、Hono 中间件、Drizzle ORM 模式

故障排除

加载 references/troubleshooting.md，查看完整的故障排除指南、性能提示和最佳实践。

快速参考

常见问题：

1. 需要 TypeScript 严格模式 → 在 tsconfig.json 中启用
2. 包体积过大 → 使用 z.lazy() 进行代码分割
3. 异步细化速度慢 → 缓存或防抖
4. 循环依赖 → 使用 z.lazy()
5. 联合类型处理缓慢 → 使用 z.discriminatedUnion()
6. 混淆转换与细化 → 使用 .refine() 进行验证，使用 .transform() 进行修改

性能提示：

• 使用 .discriminatedUnion()（比 .union() 快 5–10 倍）
• 缓存架构实例
• 使用 .safeParse()（避免 try-catch 开销）
• 延迟加载大型架构

最佳实践：

• 在模块级别定义架构
• 使用类型推断（z.infer）
• 添加自定义错误消息
• 在系统边界进行验证
• 组合小型架构
• 使用 .meta() 添加文档

→ 加载 references/troubleshooting.md，了解： 详细解决方案、性能优化、最佳实践、测试模式

快速参考

// Primitives
z.string(), z.number(), z.boolean(), z.date(), z.bigint()

// Collections
z.array(), z.tuple(), z.object(), z.record(), z.map(), z.set()

// Special types
z.enum(), z.union(), z.discriminatedUnion(), z.intersection()
z.literal(), z.any(), z.unknown(), z.never()

// Modifiers
.optional(), .nullable(), .nullish(), .default(), .prefault()
.catch(), .readonly(), .brand(), .exactOptional()

// Validation
.min(), .max(), .length(), .regex()
.refine(), .superRefine(), .check(z.minLength(3))

// Top-level formats (v4)
z.email(), z.uuid(), z.url(), z.iso.datetime(), z.file(), z.json()

// Transformation
.transform(), .pipe(), .codec(), z.preprocess(), z.custom()

// Composition helpers
z.strictObject(), z.looseObject(), z.xor(), z.templateLiteral()

// Parsing
.parse(), .safeParse(), .parseAsync(), .safeParseAsync()

// Type inference
z.infer<typeof Schema>, z.input<typeof Schema>, z.output<typeof Schema>

// Error handling
z.flattenError(), z.treeifyError(), z.prettifyError()

// JSON Schema
z.toJSONSchema(schema, options)

// Metadata
.meta(), .describe()

// Object methods
.extend(), .safeExtend(), .pick(), .omit(), .partial(), .required()
.catchall(), .keyof()  // .merge() is deprecated — use .extend(other.shape)

何时加载参考资料

遇到以下情况时，加载 references/migration-guide.md：

• 从 Zod v3 升级到 v4
• 有关破坏性变更的问题
• 需要迁移清单或回滚策略
• 遇到与已弃用 API（.merge()、error.format() 等）相关的错误
• 数字验证问题，例如 Infinity 或不安全整数

遇到以下情况时，加载 references/error-handling.md：

• 需要为表单或 UI 格式化错误
• 实现自定义错误消息
• 有关 z.flattenError()、z.treeifyError() 或 z.prettifyError() 的问题
• 设置错误消息本地化
• 需要错误代码参考或模式示例

遇到以下情况时，加载 references/advanced-patterns.md：

• 实现自定义细化或异步验证
• 需要双向转换（编解码器）
• 处理递归类型或自引用数据
• 有关 .refine()、.transform() 或 .codec() 的问题
• 需要性能优化模式
• 实现条件验证

遇到以下情况时，加载 references/type-inference.md：

• 有关 TypeScript 类型推断的问题
• 需要为 OpenAPI 或 AI 生成 JSON Schema
• 为表单或文档实现元数据系统
• 需要用于类型安全元数据的自定义注册表
• 有关 z.infer、z.input、z.output 的问题
• 使用品牌类型确保 ID 安全

遇到以下情况时，加载 references/ecosystem-integrations.md：

• 与 tRPC、React Hook Form、Prisma 或 NestJS 集成
• 设置 ESLint 插件以遵循最佳实践
• 从 OpenAPI 生成 Zod 模式（orval、Hey API、kubb）
• 有关 Hono 中间件或 Drizzle ORM 的问题
• 需要特定框架的集成示例

遇到以下情况时，加载 references/troubleshooting.md：

• 遇到 TypeScript strict 模式错误
• 有包体积方面的顾虑或需要延迟加载
• 大型联合类型或异步细化导致性能问题
• 有关循环依赖的问题
• 需要最佳实践或测试模式
• 不清楚 .refine() 和 .transform() 的区别

遇到以下情况时，加载 references/best-practices.md：

• 编写生产环境中的 Zod 代码或审查 Zod 用法
• 决定使用严格对象还是宽松对象、可选还是可空、any 还是 unknown
• 优化热点路径（模式缓存、避免动态创建模式、大型数组）
• 不确定应在哪里进行验证（边界、JSON.parse、重复验证）
• 需要包含“何时不要使用”指南的错误示例/正确示例

附加资源

• 官方文档：https://zod.dev
• GitHub：https://github.com/colinhacks/zod
• TypeScript Playground：https://zod-playground.vercel.app
• Zod Mini：https://zod.dev/packages/mini
• ESLint 插件（最佳实践）：https://github.com/JoshuaKGoldberg/eslint-plugin-zod-x
• tRPC 集成：https://trpc.io
• 生态系统：https://zod.dev/ecosystem

---

生产说明：

• 软件包版本：4.4.x（所有 API 均已针对 [email protected] 验证）
• 零依赖
• 打包体积：核心约 5kb / zod/mini 约 1.9kb（gzip 压缩后）
• 需要 TypeScript 5.5+
• 需要严格模式
• 上次验证时间：2026-08-20
• Skill 版本：2.1.0（保真度审查 + 最佳实践规则）

2.1.0 版更新内容：

• 🔍 保真度审查：针对 [email protected] 验证了每个文档中介绍的 API（类型检查 + 运行时测试）
• 📜 新增 references/best-practices.md 规则手册（Incorrect/Correct/When-NOT 格式，附影响评级）
• ➕ 新增覆盖内容：zod/mini、.check()、catchall、z.preprocess、z.custom、z.templateLiteral、z.file/z.json/z.stringbool/z.xor、z.exactOptional、.safeExtend、z.fromJSONSchema、扩展的格式验证器
• 🐛 修复：安装命令、z.string().uuid() → z.uuid()、v3 .merge()/z.function() 链式调用、.deepPartial()（已在 v4 中移除）、单参数 z.record、toJSONSchema 的 metadata 选项

2.0.0 版更新内容：

• ✨ 提供全面的 v3 到 v4 迁移指南，涵盖破坏性变更
• ✨ 通过三级系统增强错误自定义功能
• ✨ 借助注册表系统扩展元数据 API
• ✨ 通过实用示例改进错误格式化
• ✨ 内置支持 40 多种语言环境的本地化功能
• ✨ 提供包含真实场景模式的详细编解码器文档
• ✨ 说明性能改进和架构变更