PricingLoginStart free
TypeScript Academy · Lektion

Sammensætning og raffinering af skemaer

Byg komplekse skemaer med refine, transform og unioner

Lektion 4 af 413 trin

Sammensætning og raffinering af skemaer er en gratis TypeScript Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i TypeScript Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Skemaer kan sættes sammen

Zod-skemaer er byggesten, der kan sættes sammen. Du kan forfine, transformere, udvide og kombinere dem for at beskrive komplekse valideringsregler.

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

Brugerdefinerede regler med refine

.refine tilføjer et brugerdefineret valideringsprædikat med en fejlmeddelelse til regler, som Zod ikke har indbygget understøttelse af.

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.

Forfining på tværs af felter

Anvend .refine på et objekt for at validere relationer mellem felter, f.eks. at en adgangskode og bekræftelsen af den matcher.

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.

Transformation af værdier

.transform konverterer en valideret værdi til en anden struktur, efter at valideringen er gennemført.

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

Valgfrie felter

.optional() gør det tilladt, at et felt mangler, hvilket afspejles i både valideringen og den udledte type.

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

Standardværdier

.default leverer en værdi, når inputdata mangler, så det fortolkede resultat altid har feltet udfyldt.

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

Unionsskemaer

z.union accepterer en værdi, der passer til ét af flere skemaer. Det svarer i Zod til en TypeScript-union.

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

Diskriminerede unioner i Zod

z.discriminatedUnion validerer mærkede unioner effektivt ved at skifte ud fra et diskriminatorfelt.

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.

Sammenlægning med extend

.extend tilføjer felter til et eksisterende objektskema, så du kan opbygge større skemaer ud fra mindre.

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

Kombination af objektskemaer

Du kan også sammenlægge to objektskemaer med .merge og kombinere alle deres felter i ét skema.

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 }

Sammenkædning af det hele

Forfininger, transformationer, standardværdier og udvidelser kan kædes flydende sammen, så du kan udtrykke omfattende validering i ét læsbart skema.

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.

Hurtig kontrol: Sammensætning af skemaer

Test din forståelse af sammensætning og forfining af skemaer.

Besvar den i den interaktive lektion

Opsummering: Sammensætning og forfining af skemaer

Du lærte at tilføje brugerdefinerede regler med .refine, ændre værdiernes struktur med .transform, håndtere manglende data med .optional og .default, kombinere alternativer med z.union og udvide skemaer med .extend og .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.
Gratis at komme i gang

Lær TypeScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
101
Lektioner
352
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Sammensætning og raffinering af skemaer” gratis?

Ja — hele teksten til “Sammensætning og raffinering af skemaer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af TypeScript Academy-kurset, skal du opgradere til CoddyKit PRO. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Sammensætning og raffinering af skemaer”?

Byg komplekse skemaer med refine, transform og unioner Du øver dig i TypeScript Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på TypeScript Academy?

Der kræves ingen tidligere erfaring. TypeScript Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Sammensætning og raffinering af skemaer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne TypeScript Academy-lektion?

Ja. Alle TypeScript Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Grundlæggende Zod-skematypning
  2. Inferens af typer fra skemaer
  3. parse kontra safeParse
  4. Sammensætning og raffinering af skemaer
← Tilbage til TypeScript Academy