当前位置：首页 > 文章列表 > 文章 > 前端 > 使用 Zod 和 Faker 构建用于生成模拟数据的 TypeScript 助手

使用 Zod 和 Faker 构建用于生成模拟数据的 TypeScript 助手

来源：dev.to 2024-11-08 08:03:56 0浏览收藏

推广推荐

支持 PC / 移动端，安全直达

怎么入门文章编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《使用 Zod 和 Faker 构建用于生成模拟数据的 TypeScript 助手》，涉及到，有需要的可以收藏一下

构建应用程序时，模拟数据对于测试、开发和原型设计非常宝贵。借助 zod 强大的模式验证和 faker 的数据生成功能，我们可以创建一个强大的助手来为任何 zod 模式生成真实的、符合模式的模拟数据。

介绍

在本指南中，我们将创建一个辅助函数generatemockdatafromschema，它接受 zod 模式并返回与该模式的结构和验证规则匹配的模拟数据。让我们一步步深入吧！

文章演练

简介
文章演练
代码片段
为什么使用 zod 和 faker 来模拟数据？
创建模拟数据生成器
- generatemockdatafromschema 辅助函数
- 处理每种模式类型
  - 有特定要求的字符串
  - 数值
  - 布尔值
  - 数组
  - 可选字段和可为空字段
  - 具有嵌套字段的对象
- 用法示例
- 添加自定义选项
- 测试辅助函数
结论

代码片段

模拟数据生成器辅助函数
react 示例 stackblitz

为什么使用 zod 和 faker 来模拟数据？

在开始编码之前，让我们讨论一下为什么 zod 和 faker 非常适合这项任务：

zod：提供了一种健壮、类型安全的方法来在 typescript 中定义数据模式。其架构验证功能可确保我们的模拟数据符合特定规则，例如电子邮件格式、uuid 或最小/最大值。
faker：生成真实的随机数据，例如姓名、日期、电子邮件和 url。当我们需要类似于真实场景的模拟数据时，这特别有用，使其非常适合测试和演示目的。

结合 zod 和 faker 使我们能够创建既真实又符合架构的模拟数据。

创建模拟数据生成器

我们解决方案的核心是generatemockdatafromschema辅助函数，它可以解释zod模式并生成匹配的模拟数据。该函数处理各种数据类型（字符串、数字、数组、对象）并遵守每种模式类型内的验证约束。让我们探索一下它是如何构建的。

generatemockdatafromschema 辅助函数

generatemockdatafromschema 函数接受两个参数：

schema：zod schema，定义数据的形状和规则。
options（可选）：用于自定义数组长度和可选字段行为的对象。

这是该函数，分为每个部分来解释不同模式类型的处理。

import {
  zodschema,
  zodobject,
  zodstring,
  zodnumber,
  zodboolean,
  zodarray,
  zodoptional,
  zodnullable,
  zodtypeany,
  zodstringcheck,
} from "zod";
import { faker } from "@faker-js/faker";
import { z } from "zod";

const handlestringcheck = (check: zodstringcheck) => {
  switch (check.kind) {
    case "date":
      return faker.date.recent().toisostring();
    case "url":
      return faker.internet.url();
    case "email":
      return faker.internet.email();
    case "uuid":
    case "cuid":
    case "nanoid":
    case "cuid2":
    case "ulid":
      return crypto.randomuuid();
    case "emoji":
      return faker.internet.emoji();
    default:
      return faker.lorem.word();
  }
};

type generatorprimitiveoptions = {
  array?: {
    min?: number;
    max?: number;
  };
  optional?: {
    probability?: number;
  };
};

const getarraylength = (options?: generatorprimitiveoptions) => {
  return faker.number.int({
    min: options?.array?.min || 1,
    max: options?.array?.max || 10,
  });
};

export function generatetestdatafromschema<t>(
  schema: zodschema<t>,
  options?: generatorprimitiveoptions
): t {
  if (schema instanceof zodstring) {
    const check = schema._def.checks.find((check) => handlestringcheck(check));
    if (check) {
      return handlestringcheck(check) as t;
    }
    return faker.lorem.word() as t;
  }

  if (schema instanceof zodnumber) {
    return faker.number.int() as t;
  }

  if (schema instanceof zodboolean) {
    return faker.datatype.boolean() as t;
  }

  if (schema instanceof zodarray) {
    const arrayschema = schema.element;
    const length = getarraylength(options);
    return array.from({ length }).map(() =>
      generatetestdatafromschema(arrayschema)
    ) as t;
  }

  if (schema instanceof zodoptional || schema instanceof zodnullable) {
    const probability = options?.optional?.probability || 0.5;
    return (
      math.random() > probability
        ? generatetestdatafromschema(schema.unwrap())
        : null
    ) as t;
  }

  if (schema instanceof zodobject) {
    const shape = schema.shape;
    const result: any = {};
    for (const key in shape) {
      result[key] = generatetestdatafromschema(shape[key] as zodtypeany);
    }
    return result as t;
  }

  throw new error("unsupported schema type", {
    cause: schema,
  });
}

处理每种模式类型

在generatemockdatafromschema中，每种zod模式类型（如zodstring、zodnumber等）都会进行不同的处理，以适应其独特的需求。让我们来看看每种类型。

有特定要求的字符串

对于 zodstring，我们需要考虑任何特定的检查，例如电子邮件、url 或 uuid。这就是我们的辅助函数 handlestringcheck 的用武之地。它检查字符串模式，如果存在任何检查，则返回相关的模拟值（例如，电子邮件为电子邮件，网址为 url）。如果没有找到特定的检查，则默认生成随机单词。

const handlestringcheck = (check: zodstringcheck) => {
  switch (check.kind) {
    case "date":
      return faker.date.recent().toisostring();
    case "url":
      return faker.internet.url();
    case "email":
      return faker.internet.email();
    case "uuid":
    case "cuid":
    case "nanoid":
    case "cuid2":
    case "ulid":
      return crypto.randomuuid();
    case "emoji":
      return faker.internet.emoji();
    default:
      return faker.lorem.word();
  }
};

在generatemockdatafromschema中，我们使用这个助手为带有检查的字符串字段生成数据。

数值

对于 zodnumber，我们使用 faker 的 faker.number.int() 方法生成整数。如果在架构中定义了最小值和最大值，则可以进一步自定义此部分以处理最小值和最大值。

if (schema instanceof zodnumber) {
  return faker.number.int() as t;
}

布尔值

对于布尔值，faker 提供了一个简单的 faker.datatype.boolean() 函数来随机生成 true 或 false 值。

if (schema instanceof zodboolean) {
  return faker.datatype.boolean() as t;
}

数组

在处理 zodarray 时，我们为数组中的每个元素递归生成模拟数据。我们还允许使用 options 参数自定义数组长度。

要生成数组，我们首先使用 getarraylength 确定长度，这是一个辅助函数，用于检查选项中的最小和最大长度。对于每个数组元素，都会递归调用generatemockdatafromschema，确保数组中的嵌套模式也得到处理。

type generatorprimitiveoptions = {
  array?: {
    min?: number;
    max?: number;
  };
  optional?: {
    probability?: number;
  };
};

if (schema instanceof zodoptional || schema instanceof zodnullable) {
  const probability = options?.optional?.probability || 0.5;
  return (
    math.random() > probability
      ? generatetestdatafromschema(schema.unwrap())
      : null
  ) as t;
}

const getarraylength = (options?: generatorprimitiveoptions) => {
  return faker.number.int({
    min: options?.array?.min || 1,
    max: options?.array?.max || 10,
  });
};

可选字段和可为空字段

可选字段和可为空字段是通过随机决定是否将它们包含在输出中来处理的。 options.optional.probability 设置允许我们控制这个概率。如果生成了一个字段，它会递归调用generatemockdatafromschema来获取内部模式。

if (schema instanceof zodoptional || schema instanceof zodnullable) {
  const shouldgenerate =
    math.random() > (options?.optional?.probability || 0.5);
  return shouldgenerate
    ? generatemockdatafromschema(schema.unwrap(), options)
    : null;
}

具有嵌套字段的对象

对于 zodobject，我们迭代每个键值对并递归地为每个字段生成数据。这种方法支持深度嵌套的对象，使其高度灵活。

if (schema instanceof zodobject) {
  const shape = schema.shape;
  const result: any = {};
  for (const key in shape) {
    result[key] = generatemockdatafromschema(shape[key] as zodtypeany, options);
  }
  return result as t;
}

用法示例

generatemockdatafromschema 就位后，让我们看看它的实际效果。这是一个示例架构 userschema，具有不同的类型、可选字段和嵌套数组。

export const userschema = z.object({
  id: z.string().uuid(),
  name: z.string().min(1).max(100),
  email: z.string().email(),
  friends: z.array(
    z.object({
      id: z.string().uuid(),
      name: z.string(),
    })
  ),
});

const mockdata = generatemockdatafromschema(userschema);
console.log(mockdata);

添加自定义选项

generatemockdatafromschema 函数还接受可选的 options 参数来自定义数组长度和可选字段行为。以下是如何使用这些选项的示例：

const mockdata = generatemockdatafromschema(userschema, {
  array: { min: 2, max: 5 },
  optional: { probability: 0.7 },
});

这将确保数组字段的长度在 2 到 5 之间，并且可选字段的生成概率为 70%。

测试辅助函数

要确认generatemockdatafromschema 按预期工作，请为不同的架构配置创建单元测试。以下是数组模式测试的示例：

import { UserSchema } from "./schemas";
import { generateMockDataFromSchema } from "./mockDataGenerator";
import { z } from "zod";

describe("Generates mock data for array schema", () => {
  const schema = z.array(z.string());
  const mockData = generateMockDataFromSchema(schema, {
    array: { min: 3, max: 3 },
  });
  expect(mockData).toHaveLength(3);
  expect(mockData.every((item) => typeof item === "string")).toBe(true);
});

describe("generateMockDataFromSchema", () => {
  it("should generate data matching the schema", () => {
    const mockData = generateMockDataFromSchema(UserSchema);
    expect(mockData).toHaveProperty("id");
    expect(typeof mockData.name).toBe("string");
    expect(mockData.friends).toBeInstanceOf(Array);
  });
});

test("Generates valid mock data for UserSchema", () => {
  const userData = generateTestDataFromSchema(UserSchema);
  expect(UserSchema.safeParse(userData).success).toBe(true);
});

通过为各种模式类型和配置编写测试，您可以确保辅助函数在不同场景下正确运行。