PricingLoginStart free
TypeScript Academy · Lekcja

Walidacja schematów za pomocą zod i inferencja do TS

Walidowanie żądań za pomocą zod, wyprowadzanie typów TypeScript ze schematów oraz dodawanie bezpiecznego middleware i obsługi błędów

Lekcja 2 z 38 kroki

Walidacja schematów za pomocą zod i inferencja do TS to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 2 z 3. 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 3 lekcji w sumie.

Wprowadzenie

Cel: Walidować dane wejściowe za pomocą zod i utrzymywać synchronizację typów TypeScript za pomocą z.infer. Będziesz bezpiecznie parsować dane, zwracać pomocne błędy i podłączać walidację do middleware.

  • Jednokrotne definiowanie schematów
  • Inferowanie typów TS
  • safeParse i błędy 400

Schemat i infer

Modeluj dane jednokrotnie za pomocą zod. Pochodny typ type User = z.infer<typeof userSchema> dokładnie odzwierciedla walidację.

import { z } from "zod"

export const userSchema = z.object({
  id: z.string().regex(/^u_[a-z0-9]+$/),
  name: z.string().min(1),
  age: z.number().int().nonnegative().optional()
})

export type User = z.infer<typeof userSchema>

// Reuse `User` across handlers, services, and tests

safeParse w handlerze

Użyj safeParse, aby uniknąć wyjątków; zwracaj 400 ze sformatowanymi problemami. Typ odpowiedzi odzwierciedla zarówno kształt sukcesu, jak i błędu.

import { Request, Response } from "express"
import { userSchema, User } from "./schema"

export function createUser(req: Request<{}, User, unknown>, res: Response<User | { error: string; issues?: unknown }>) {
  const parsed = userSchema.safeParse(req.body)
  if (!parsed.success) {
    return res.status(400).json({ error: "Invalid body", issues: parsed.error.format() })
  }
  const user = parsed.data
  return res.status(201).json(user)
}

Pomocniczy middleware

Utwórz middleware wielokrotnego użytku. Parsuje ono body i albo dołącza typowane dane, albo zwraca 400 ze szczegółami.

import { z } from "zod"
import { Request, Response, NextFunction } from "express"

export function validateBody<T extends z.ZodTypeAny>(schema: T) {
  return (req: Request, res: Response, next: NextFunction) => {
    const r = schema.safeParse(req.body)
    if (!r.success) {
      return res.status(400).json({ error: "Invalid body", issues: r.error.format() })
    }
    req.body = r.data
    next()
  }
}

Koercja i refine

Należy użyć z.coerce do akceptowania liczb zapisanych jako ciągi znaków, z.enum dla znanych wartości, a .refine dla reguł obejmujących wiele pól.

import { z } from "zod"

const signupSchema = z.object({
  email: z.string().email(),
  age: z.coerce.number().int().gte(13),
  role: z.enum(["user", "admin"]).default("user")
}).refine(v => v.role !== "admin" || v.age >= 18, { message: "admin must be adult" })

export type Signup = z.infer<typeof signupSchema>

// Coercion allows numbers in strings; refine adds cross-field rules

Wskazówki dotyczące błędów

Wskazówki dotyczące błędów:

  • Na granicy systemu zawsze należy używać safeParse.
  • Należy formatować problemy na potrzeby klientów i unikać ujawniania śladów stosu.
  • Przy przechwytywaniu rzuconych wyników parsowania należy zawęzić unknown do ZodError.

Sprawdzenie inferencji zod

Szybkie sprawdzenie: Jak zachować synchronizację typów TS ze schematami zod?

Odpowiedz w interaktywnej lekcji

Podsumowanie

Podsumowanie: Należy zdefiniować jeden schemat, wywnioskować typ TS, przeprowadzać walidację za pomocą safeParse i podłączyć schemat do middleware, aby zapewnić spójne błędy 400.

Bezpłatny start

Ucz się TypeScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
101
Lekcje
352
Zacznij naukę bezpłatnieWyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Walidacja schematów za pomocą zod i inferencja do TS” jest bezpłatna?

Tak — pełny tekst „Walidacja schematów za pomocą zod i inferencja do TS” 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 3 lekcji w sumie.

Co nauczysz się w „Walidacja schematów za pomocą zod i inferencja do TS”?

Walidowanie żądań za pomocą zod, wyprowadzanie typów TypeScript ze schematów oraz dodawanie bezpiecznego middleware i obsługi błędów Ć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 2 z 3.

Ile czasu zajmuje lekcja „Walidacja schematów za pomocą zod i inferencja do TS”?

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

  1. Typowanie handlerów routera, Request/Response
  2. Walidacja schematów za pomocą zod i inferencja do TS
  3. Middleware błędów i typy Result
← Powrót do TypeScript Academy