TypeScript Academy · Lekcja

Podstawy schematów Zod

Definiuj schematy dla prymitywów, obiektów i tablic

Podstawy schematów Zod to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Po co walidacja w czasie działania programu

Typy TypeScript znikają w czasie działania programu. Dane z API, formularzy i plików są nietypowane na granicy systemu. Zod weryfikuje te dane w czasie działania programu i dodatkowo dostarcza ich typy.

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

Importowanie Zod

Proszę wprowadzić przestrzeń nazw z z pakietu zod. Każdy konstruktor schematu znajduje się w z.

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

Schematy typów prostych

Zod udostępnia konstruktory dla typów prostych: z.string(), z.number() i z.boolean() weryfikują odpowiednio jeden rodzaj wartości.

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

Weryfikowanie wartości

Proszę wywołać .parse na schemacie, aby przeprowadzić walidację. Metoda zwraca wartość, jeśli jest poprawna, a w przeciwnym razie zgłasza wyjątek.

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

Schematy obiektów

z.object opisuje strukturę obiektu, przypisując każdemu kluczowi schemat jego wartości.

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

Schematy tablic

z.array weryfikuje, czy wartość jest tablicą, której wszystkie elementy pasują do podanego schematu.

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

Zagnieżdżanie schematów

Schematy można komponować. Obiekt może zawierać tablice i inne obiekty, odwzorowując strukturę rzeczywistych danych.

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.

Typy boolean i number razem

Można połączyć wiele typów pól w jednym schemacie obiektu, aby opisać realistyczne rekordy.

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 });

Schematy są wartościami

Schemat Zod jest zwykłą wartością JavaScript, którą można przechowywać, przekazywać i ponownie wykorzystywać, w przeciwieństwie do typu TypeScript, który istnieje wyłącznie w czasie kompilacji.

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.

Weryfikowanie nieznanych danych wejściowych

Zod doskonale nadaje się do danych typu unknown, takich jak sparsowany payload JSON, ponieważ jednocześnie bezpiecznie je sprawdza i zawęża ich typ.

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

Elementy składowe kursu

Za pomocą z.object, z.string, z.number, z.array i z.boolean można opisać większość danych. Następnie wywnioskujemy typy TypeScript z tych schematów.

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.

Szybki test: podstawy Zod

Sprawdź swoją wiedzę na temat podstaw schematów Zod.

Podsumowanie: podstawy schematów Zod

Dowiedział się Pan lub dowiedziała się Pani, jak importować z, budować schematy za pomocą z.object, z.string, z.number, z.array i z.boolean, a następnie weryfikować wartości w czasie działania programu za pomocą .parse.

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

Często zadawane pytania

Czy lekcja „Podstawy schematów Zod” jest bezpłatna?

Tak — pełny tekst „Podstawy schematów Zod” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Podstawy schematów Zod”?

Definiuj schematy dla prymitywów, obiektów i tablic Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Podstawy schematów Zod”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do TypeScript Academy