Convertitore da JSON a schema Zod

Cos'è uno schema Zod?

Esempi

{"id":101,"name":"Ada Lovelace","email":"ada@example.com","active":true,"roles":["admin","user"]}

import { z } from "zod";

export const RootSchema = z.object({
  id: z.number().int(),
  name: z.string(),
  email: z.string(),
  active: z.boolean(),
  roles: z.array(z.string()),
});

export type Root = z.infer<typeof RootSchema>;

{"repo":"zod","owner":{"login":"colinhacks","id":100}}

import { z } from "zod";

export const OwnerSchema = z.object({
  login: z.string(),
  id: z.number().int(),
});

export const RootSchema = z.object({
  repo: z.string(),
  owner: OwnerSchema,
});

export type Root = z.infer<typeof RootSchema>;

{"users":[{"id":1,"nick":"x"},{"id":2}]}

import { z } from "zod";

export const UserSchema = z.object({
  id: z.number().int(),
  nick: z.string().optional(),
});

export const RootSchema = z.object({
  users: z.array(UserSchema),
});

export type Root = z.infer<typeof RootSchema>;

{"items":[{"sku":"A1","discount":0.1},{"sku":"A2","discount":null}]}

import { z } from "zod";

export const ItemSchema = z.object({
  sku: z.string(),
  discount: z.number().nullable(),
});

export const RootSchema = z.object({
  items: z.array(ItemSchema),
});

export type Root = z.infer<typeof RootSchema>;

Come convertire JSON in Zod

1. 1

   Incolla il tuo JSON

   Inserisci un oggetto JSON, un array o una risposta API nel campo di input. La conversione parte istantaneamente.

2. 2

   Regola l'output

   Rinomina lo schema radice e attiva o meno la riga import, il tipo z.infer o la parola chiave export per adattarlo allo stile del tuo progetto.

3. 3

   Copia o scarica

   Prendi lo schema Zod generato con un clic e incollalo direttamente nel tuo livello di validazione.

Common Use Cases

Validare le risposte API

Trasforma una risposta di esempio REST o GraphQL in uno schema Zod e analizzala al confine del fetch, così i dati mal formati falliscono subito con un errore chiaro invece di filtrare attraverso la tua app.

Moduli e input tipizzati

Genera uno schema per l'input di un modulo o di una query e riutilizza il tipo z.infer nella tua interfaccia e nei tuoi handler per una sicurezza dei tipi end-to-end.

Schemi tRPC e strumenti IA

Avvia gli schemi di input e output delle procedure tRPC o degli strumenti IA a output strutturato a partire da un payload di esempio invece di scriverli a mano.

Come funziona la conversione

Inferenza strutturale

Ogni oggetto diventa uno schema con nome; le forme identiche vengono dichiarate una sola volta e riutilizzate. Gli array di oggetti si uniscono chiave per chiave, e le chiavi assenti in alcuni elementi diventano .optional().

Corrispondenza dei tipi corretta

Gli interi vengono mappati su z.number().int() e i decimali su z.number(). Le stringhe, i booleani e i null vengono mappati su z.string(), z.boolean() e z.null(); un array di primitivi misti diventa un z.union().

Tipi TypeScript inclusi

Viene emesso un alias di tipo z.infer per lo schema radice, così lo schema resta l'unica fonte di verità e i tuoi tipi non divergono mai dalla tua validazione.

100% lato client

Il parsing e la generazione girano nel tuo browser senza chiamate di rete, così i tuoi dati restano privati.

Consigli per schemi Zod puliti

Dai un nome allo schema radice

Imposta un nome radice significativo come User o ApiResponse invece del Root predefinito per un codice leggibile e autodocumentato.

Affina z.unknown() e le union

Gli array vuoti o misti producono z.unknown() o un z.union() ampio. Incolla un campione più ricco e rappresentativo così lo strumento deduce tipi precisi, poi restringi tutto ciò che resta ambiguo.

Valida al confine

Chiama safeParse() dove entrano dati non attendibili — risposte API, input dei moduli, webhook — così i dati errati vengono intercettati prima di raggiungere la logica della tua applicazione.

Domande frequenti