TypeScript Academy · Lekcja

Komponowanie i udoskonalanie schematów

Buduj złożone schematy za pomocą refine, transform i unii

Komponowanie i udoskonalanie schematów to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 4 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.

Schematy można komponować

Schematy Zod są elementami składowymi, które można komponować. Można je uszczegóławiać, przekształcać, rozszerzać i łączyć, aby opisywać złożone reguły walidacji.

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

Własne reguły za pomocą refine

.refine dodaje własny predykat walidacyjny wraz z komunikatem błędu, umożliwiając definiowanie reguł, dla których Zod nie ma wbudowanej obsługi.

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.

Walidowanie zależności między polami

.refine można zastosować do obiektu, aby weryfikować zależności między polami, na przykład zgodność hasła z jego potwierdzeniem.

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.

Przekształcanie wartości

.transform przekształca zweryfikowaną wartość w inną strukturę po pomyślnym zakończeniu walidacji.

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

Pola opcjonalne

.optional() pozwala pominąć pole, co znajduje odzwierciedlenie zarówno w walidacji, jak i w wywnioskowanym typie.

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

Wartości domyślne

.default dostarcza wartość, gdy brakuje jej na wejściu, dzięki czemu sparsowany wynik zawsze zawiera wypełnione pole.

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

Schematy unii

z.union akceptuje wartość pasującą do dowolnego z kilku schematów — jest odpowiednikiem unii TypeScript w Zod.

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

Unie rozłączne w Zod

z.discriminatedUnion wydajnie weryfikuje unie oznaczone tagami, wybierając wariant na podstawie pola rozróżniającego.

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.

Scalanie za pomocą extend

.extend dodaje pola do istniejącego schematu obiektu, umożliwiając budowanie większych schematów z mniejszych.

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

Łączenie schematów obiektów

Można również scalić dwa schematy obiektów za pomocą .merge, łącząc wszystkie ich pola w jeden schemat.

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 }

Łączenie wszystkich elementów

Uszczegółowienia, przekształcenia, wartości domyślne i rozszerzenia można płynnie łączyć, aby wyrazić rozbudowaną walidację w jednym czytelnym schemacie.

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.

Szybki test: komponowanie schematów

Sprawdź swoją wiedzę na temat komponowania i uszczegóławiania schematów.

Podsumowanie: komponowanie i uszczegóławianie schematów

Dowiedział się Pan lub dowiedziała się Pani, jak dodawać własne reguły za pomocą .refine, zmieniać strukturę wartości za pomocą .transform, obsługiwać brakujące dane za pomocą .optional i .default, łączyć alternatywy za pomocą z.union oraz rozbudowywać schematy za pomocą .extend i .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.

Często zadawane pytania

Czy lekcja „Komponowanie i udoskonalanie schematów” jest bezpłatna?

Tak — pełny tekst „Komponowanie i udoskonalanie schematów” 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 „Komponowanie i udoskonalanie schematów”?

Buduj złożone schematy za pomocą refine, transform i unii Ć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 4 z 4.

Ile czasu zajmuje lekcja „Komponowanie i udoskonalanie schematów”?

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