TypeScript Academy · Lektion

Grunderna i Zod-scheman

Definiera scheman för primitiva typer, objekt och arrayer.

Lektion 1 av 413 steg

Grunderna i Zod-scheman är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Varför validering vid körning?

TypeScript-typer försvinner vid körning. Data från API:er, formulär och filer saknar typ vid gränsen mot programmet. Zod validerar dessa data vid körning och ger er dessutom typer.

import { z } from "zod";
// Types check at compile time; Zod checks values at runtime.

Importera Zod

Importera namnrymden z från paketet zod. Alla schemabyggare finns på z.

import { z } from "zod";
const nameSchema = z.string();
// nameSchema validates that a value is a string.

Primitiva scheman

Zod erbjuder byggare för primitiva typer: z.string(), z.number() och z.boolean() validerar var och en en typ av värde.

import { z } from "zod";
const name = z.string();
const age = z.number();
const active = z.boolean();
// Use .parse(value) to validate at runtime.

Validera ett värde

Anropa .parse på ett schema för att validera det. Metoden returnerar värdet om det är giltigt och kastar ett undantag annars.

import { z } from "zod";
const schema = z.string();
const result = schema.parse("hello"); // "hello"
const broken = schema.parse(123); // throws ZodError

Objektscheman

z.object beskriver strukturen hos ett objekt genom att koppla varje nyckel till ett schema för dess värde.

import { z } from "zod";
const userSchema = z.object({
  name: z.string(),
  age: z.number()
});
// userSchema.parse({ name: "Ada", age: 36 }) succeeds.

Array-scheman

z.array validerar att ett värde är en array vars element alla matchar ett angivet schema.

import { z } from "zod";
const tags = z.array(z.string());
// tags.parse(["a", "b"]) succeeds; tags.parse([1]) throws.

Kapsla scheman

Scheman kan kombineras. Ett objekt kan innehålla arrayer och andra objekt, vilket speglar strukturen hos era faktiska data.

import { z } from "zod";
const post = z.object({
  title: z.string(),
  tags: z.array(z.string()),
  author: z.object({ name: z.string() })
});
// Validates nested structure in one call.

Boolean och tal tillsammans

Kombinera flera fälttyper i ett objektschema för att beskriva realistiska poster.

import { z } from "zod";
const product = z.object({
  name: z.string(),
  price: z.number(),
  inStock: z.boolean()
});
// product.parse({ name: "Pen", price: 2, inStock: true });

Scheman är värden

Ett Zod-schema är ett vanligt JavaScript-värde som kan lagras, skickas vidare och återanvändas, till skillnad från en TypeScript-typ som bara finns vid kompilering.

import { z } from "zod";
const emailSchema = z.string();
function check(s: typeof emailSchema, v: unknown) {
  return s.parse(v);
}
// You can pass schemas as arguments.

Validera okänd indata

Zod passar utmärkt för data av typen unknown, till exempel en tolkad JSON-payload, eftersom värdet både kontrolleras och typavgränsas på ett säkert sätt.

import { z } from "zod";
const schema = z.object({ id: z.number() });
const raw: unknown = JSON.parse("{ \"id\": 1 }");
const data = schema.parse(raw); // data.id is number

Byggstenar för kursen

Med z.object, z.string, z.number, z.array och z.boolean kan ni beskriva de flesta data. Nästa steg är att inferera TypeScript-typer från dessa scheman.

import { z } from "zod";
const schema = z.object({
  name: z.string(),
  scores: z.array(z.number())
});
// One schema, ready to validate and to infer a type from.

Snabbtest: Grunderna i Zod

Testa era kunskaper om grunderna i Zod-scheman.

Besvara frågan i den interaktiva lektionen

Sammanfattning: Grunderna i Zod-scheman

Ni har lärt er att importera z och skapa scheman med z.object, z.string, z.number, z.array och z.boolean, och sedan validera värden vid körning med .parse.

import { z } from "zod";
const userSchema = z.object({ name: z.string(), age: z.number() });
// userSchema.parse({ name: "Ada", age: 36 });

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 101
Lektioner: 352

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Grunderna i Zod-scheman” gratis?

Ja – hela texten till ”Grunderna i Zod-scheman” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Grunderna i Zod-scheman”?

Definiera scheman för primitiva typer, objekt och arrayer. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Grunderna i Zod-scheman”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till TypeScript Academy