如何在Zod中高效处理深度嵌套的默认配置？

要解决深度嵌套场景下重复定义Zod默认值的问题，核心思路是复用已有的默认配置对象，通过递归工具自动生成带嵌套默认值的Zod Schema，无需手动在每个层级重复编写default()。以下是具体实现：

步骤1：定义精确类型的默认配置 #

首先给默认配置加上as const，让TypeScript推导最精确的字面量类型：

import { z } from "zod";

const defaultOptions = {
  a: 1,
  b: 2,
  c: {
    c1: 3,
    c2: 4,
    c3: { x: 1, y: 2, z: 3 }
  }
} as const;

步骤2：编写递归工具生成带默认值的Schema #

实现一个递归函数，将普通对象转换为对应结构的Zod Schema，自动为每个字段（包括嵌套字段）添加optional()和default()：

// 定义深度部分类型，支持任意层级的部分配置传入
type PartialDeep<T> = T extends object ? {
  [K in keyof T]?: PartialDeep<T[K]>;
} : T;

function createNestedDefaultSchema<T extends Record<string, unknown>>(obj: T): z.ZodType<T> {
  const schemaShape: Record<string, z.ZodTypeAny> = {};

  for (const key in obj) {
    const value = obj[key];

    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
      // 递归处理嵌套对象，自动继承默认值
      schemaShape[key] = createNestedDefaultSchema(value as Record<string, unknown>)
        .optional()
        .default(value);
    } else if (Array.isArray(value)) {
      // 处理数组类型（示例：假设数组元素类型统一）
      const itemSchema = typeof value[0] === "object" && value[0] !== null
        ? createNestedDefaultSchema(value[0] as Record<string, unknown>)
        : z.any();
      schemaShape[key] = z.array(itemSchema).optional().default(value);
    } else {
      // 处理基础类型（根据值自动匹配Zod类型）
      switch (typeof value) {
        case "number":
          schemaShape[key] = z.number().optional().default(value);
          break;
        case "string":
          schemaShape[key] = z.string().optional().default(value);
          break;
        case "boolean":
          schemaShape[key] = z.boolean().optional().default(value);
          break;
        default:
          schemaShape[key] = z.any().optional().default(value);
      }
    }
  }

  return z.object(schemaShape) as z.ZodType<T>;
}

步骤3：在函数中使用Schema #

生成Schema后，直接用parse()方法处理传入的配置——Zod会自动完成深度默认值填充和类型验证：

// 生成对应Schema
const optionsSchema = createNestedDefaultSchema(defaultOptions);

// 定义函数，参数支持任意深度的部分配置
function myFunction(options?: PartialDeep<typeof defaultOptions>) {
  // 自动填充所有嵌套默认值，同时验证传入配置的合法性
  const finalOptions = optionsSchema.parse(options);
  
  // 业务逻辑示例
  console.log(finalOptions);
}

测试效果 #

• 不传参数：myFunction() → 返回完整的defaultOptions
• 传顶层部分配置：myFunction({ a: 5 }) → a=5，其余保持默认
• 传嵌套部分配置：myFunction({ c: { c1: 10, c3: { y: 20 } } }) → c.c1=10、c.c3.y=20，c.c2和c.c3.x/z保留默认值

这种方案完全复用了已有默认配置，避免了手动重复编写嵌套默认值，同时保证了类型安全和配置验证的严谨性。

内容的提问来源于stack exchange，提问作者Timm Nicolaizik