TypeScript Academy · Lezione

Comporre e perfezionare gli schemi

Costruisca schemi complessi con refine, transform e union.

Comporre e perfezionare gli schemi è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Gli schemi sono componibili

Gli schemi Zod sono elementi costitutivi componibili. Può perfezionarli, trasformarli, estenderli e combinarli per modellare regole di convalida complesse.

import { z } from "zod";
const base = z.object({ name: z.string() });
// We will add rules and combine schemas from here.

Regole personalizzate con refine

.refine aggiunge un predicato di convalida personalizzato con un messaggio di errore, per regole che Zod non offre predefinite.

import { z } from "zod";
const password = z.string().refine(
  (s) => s.length >= 8,
  { message: "Must be at least 8 characters" }
);
// password.parse("short") throws with that message.

Perfezionare tra più campi

Applichi .refine a un oggetto per convalidare le relazioni tra i campi, ad esempio la corrispondenza tra password e conferma della password.

import { z } from "zod";
const form = z.object({
  password: z.string(),
  confirm: z.string()
}).refine((d) => d.password === d.confirm, {
  message: "Passwords must match"
});
// Validates both fields together.

Trasformare i valori

.transform converte un valore convalidato in un'altra struttura, dopo che la convalida è terminata con successo.

import { z } from "zod";
const trimmed = z.string().transform((s) => s.trim());
const result = trimmed.parse("  hi  "); // "hi"

Campi opzionali

.optional() consente che un campo sia assente, e questo si riflette sia nella convalida sia nel tipo inferito.

import { z } from "zod";
const schema = z.object({
  name: z.string(),
  bio: z.string().optional()
});
// bio may be omitted.

Valori predefiniti

.default fornisce un valore quando l'input è assente, così il risultato analizzato contiene sempre il campo valorizzato.

import { z } from "zod";
const schema = z.object({
  retries: z.number().default(3)
});
const r = schema.parse({}); // { retries: 3 }

Schema union

z.union accetta un valore che corrisponde a uno qualsiasi di diversi schemi, l'equivalente Zod di una union TypeScript.

import { z } from "zod";
const id = z.union([z.string(), z.number()]);
// id.parse("abc") and id.parse(123) both succeed.

Union discriminate in Zod

z.discriminatedUnion convalida in modo efficiente le union con tag, selezionando il ramo in base a un campo discriminante.

import { z } from "zod";
const shape = z.discriminatedUnion("kind", [
  z.object({ kind: z.literal("circle"), radius: z.number() }),
  z.object({ kind: z.literal("square"), side: z.number() })
]);
// Picks the right member by kind.

Unire con extend

.extend aggiunge campi a uno schema di oggetto esistente, consentendo di costruire schemi più grandi a partire da schemi più piccoli.

import { z } from "zod";
const base = z.object({ id: z.number() });
const user = base.extend({ name: z.string() });
// user validates { id: number; name: string }

Combinare schemi di oggetti

È anche possibile unire due schemi di oggetti con .merge, combinando tutti i loro campi in un unico schema.

import { z } from "zod";
const a = z.object({ x: z.number() });
const b = z.object({ y: z.string() });
const combined = a.merge(b);
// combined validates { x: number; y: string }

Collegare tutto insieme

Perfezionamenti, trasformazioni, valori predefiniti ed estensioni possono essere concatenati in modo fluido per esprimere una convalida articolata in un unico schema leggibile.

import { z } from "zod";
const signup = z.object({
  email: z.string().refine(s => s.includes("@"), { message: "Invalid email" }),
  age: z.number().default(18)
}).extend({
  newsletter: z.boolean().optional()
});
// One schema, many rules.

Verifica rapida: comporre gli schemi

Verifichi la Sua comprensione della composizione e del perfezionamento degli schemi.

Riepilogo: comporre e perfezionare gli schemi

Ha imparato ad aggiungere regole personalizzate con .refine, a trasformare i valori con .transform, a gestire i dati mancanti con .optional e .default, a combinare alternative con z.union e a estendere gli schemi con .extend e .merge.

import { z } from "zod";
const schema = z.object({ name: z.string() })
  .extend({ age: z.number().default(0) })
  .refine(d => d.name.length > 0, { message: "Name required" });
// Composed validation in one place.

Domande Frequenti

La lezione «Comporre e perfezionare gli schemi» è gratuita?

Sì — il testo completo di «Comporre e perfezionare gli schemi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Comporre e perfezionare gli schemi»?

Costruisca schemi complessi con refine, transform e union. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Comporre e perfezionare gli schemi»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a TypeScript Academy