TypeScript Academy · Les

Schema's samenstellen en verfijnen

Bouw complexe schema's met refine, transform en unions

Les 4 van 413 stappen

Schema's samenstellen en verfijnen is een gratis TypeScript Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.

Schema's kunnen worden samengesteld

Zod-schema's zijn samen te stellen bouwstenen. Je kunt ze verfijnen, transformeren, uitbreiden en combineren om complexe validatieregels te modelleren.

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

Aangepaste regels met refine

.refine voegt een aangepast validatiepredicaat met een foutmelding toe voor regels waarvoor Zod geen ingebouwde ondersteuning heeft.

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.

Validatie over velden verfijnen

Pas .refine toe op een object om relaties tussen velden te valideren, zoals een overeenkomende wachtwoordbevestiging.

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.

Waarden transformeren

.transform zet een gevalideerde waarde om naar een andere vorm en wordt uitgevoerd nadat de validatie is geslaagd.

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

Optionele velden

.optional() maakt het toegestaan dat een veld ontbreekt; dit wordt weerspiegeld in zowel de validatie als het afgeleide type.

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

Standaardwaarden

.default levert een waarde wanneer de invoer ontbreekt, zodat het geparseerde resultaat het veld altijd ingevuld heeft.

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

Unieschema's

z.union accepteert een waarde die overeenkomt met een van meerdere schema's, het Zod-equivalent van een TypeScript-unietype.

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

Unies met discriminant in Zod

z.discriminatedUnion valideert getagde unies efficiënt door te schakelen op basis van een discriminantveld.

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.

Samenvoegen met extend

.extend voegt velden toe aan een bestaand objectschema, zodat je grotere schema's uit kleinere kunt opbouwen.

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

Objectschema's combineren

Je kunt ook twee objectschema's samenvoegen met .merge en al hun velden combineren in één 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 }

Alles aan elkaar ketenen

Verfijningen, transformaties, standaardwaarden en uitbreidingen kunnen vloeiend aan elkaar worden gekoppeld om uitgebreide validatie in één leesbaar schema uit te drukken.

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.

Korte controle: schema's samenstellen

Test je begrip van het samenstellen en verfijnen van schema's.

Beantwoord dit in de interactieve les

Samenvatting: schema's samenstellen en verfijnen

Je hebt geleerd om aangepaste regels toe te voegen met .refine, waarden te hervormen met .transform, ontbrekende gegevens af te handelen met .optional en .default, alternatieven te combineren met z.union en schema's uit te breiden met .extend en .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 beginnen

Leer TypeScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 101
Lessen: 352

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Schema's samenstellen en verfijnen” gratis?

Ja — de volledige tekst van “Schema's samenstellen en verfijnen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.

Wat leer ik in “Schema's samenstellen en verfijnen”?

Bouw complexe schema's met refine, transform en unions Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met TypeScript Academy te beginnen?

Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Schema's samenstellen en verfijnen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?

Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar TypeScript Academy