TypeScript Academy · Lekcja

parse a safeParse

Sprawnie obsługuj powodzenie i niepowodzenie walidacji

Lekcja 3 z 413 kroki

parse a safeParse to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 3 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.

Dwa sposoby walidacji

Zod udostępnia dwie metody walidacji: parse, która zgłasza wyjątek w przypadku nieprawidłowych danych, oraz safeParse, która zamiast tego zwraca obiekt wyniku.

import { z } from "zod";
const schema = z.string();
// schema.parse(x) throws on failure
// schema.safeParse(x) returns { success, ... }

parse zgłasza wyjątek dla nieprawidłowych danych

parse zwraca zweryfikowaną wartość w przypadku powodzenia, a przy niepowodzeniu zgłasza ZodError. To dobre rozwiązanie, gdy nieprawidłowe dane są rzeczywiście sytuacją wyjątkową.

import { z } from "zod";
const schema = z.number();
const ok = schema.parse(42); // 42
// schema.parse("nope"); // throws ZodError

Obsługa błędów parse

Proszę umieścić parse w bloku try/catch, aby obsłużyć zgłoszony błąd i przeanalizować szczegóły tego, co się nie powiodło.

import { z } from "zod";
const schema = z.number();
try {
  schema.parse("nope");
} catch (err) {
  if (err instanceof z.ZodError) {
    console.log("Invalid:", err.issues.length);
  }
}

safeParse zwraca wynik

safeParse nigdy nie zgłasza wyjątku. Zwraca obiekt z success: true i data albo z success: false i error.

import { z } from "zod";
const schema = z.number();
const result = schema.safeParse("nope");
// result is { success: false, error: ZodError }

Zawężanie wyniku

Wynik jest unią rozłączną opartą na polu success. Sprawdzenie tego pola zawęża wynik do data albo error.

import { z } from "zod";
const schema = z.object({ id: z.number() });
const result = schema.safeParse({ id: 1 });
if (result.success) {
  console.log(result.data.id); // typed
} else {
  console.log(result.error.issues);
}

Kiedy używać parse

Proszę używać parse, gdy nieprawidłowe dane wejściowe są błędem lub powinny przerwać operację, na przykład podczas odczytywania wymaganej konfiguracji przy uruchamianiu programu.

import { z } from "zod";
const configSchema = z.object({ port: z.number() });
const config = configSchema.parse({ port: 8080 });
// Fail fast if config is wrong.

Kiedy używać safeParse

Proszę używać safeParse, gdy nieprawidłowe dane wejściowe są spodziewane i należy obsłużyć je w kontrolowany sposób, na przykład podczas walidowania danych przesłanych w formularzu.

import { z } from "zod";
const formSchema = z.object({ email: z.string() });
const r = formSchema.safeParse({ email: 123 });
if (!r.success) {
  // Show a friendly validation message
}

Odczytywanie problemów ZodError

ZodError zawiera tablicę issues opisującą każdy problem: ścieżkę, komunikat i kod błędu.

import { z } from "zod";
const schema = z.object({ age: z.number() });
const r = schema.safeParse({ age: "x" });
if (!r.success) {
  for (const issue of r.error.issues) {
    console.log(issue.path, issue.message);
  }
}

Obie metody zwracają wywnioskowany typ

W przypadku powodzenia obie metody zwracają zweryfikowaną wartość o typie z.infer<typeof schema>, dzięki czemu dalszy kod jest w pełni typowany.

import { z } from "zod";
const userSchema = z.object({ name: z.string() });
type User = z.infer<typeof userSchema>;
const u: User = userSchema.parse({ name: "Ada" });
console.log(u.name);

Wybór właściwej metody

Praktyczna zasada: parse należy stosować w zaufanych lub krytycznych ścieżkach, gdzie błąd powinien zatrzymać wykonanie programu, a safeParse w przypadku niezaufanych danych wejściowych, które trzeba obsłużyć bez awarii programu.

import { z } from "zod";
const schema = z.string();
// Critical: schema.parse(value)
// User-facing: schema.safeParse(value)

Łączenie obu stylów

Popularny wzorzec polega na opakowaniu safeParse w pomocniczej funkcji, która zwraca typowane dane albo sformatowany błąd, łącząc wygodę obu metod.

import { z } from "zod";
function validate<T extends z.ZodType>(schema: T, value: unknown) {
  const r = schema.safeParse(value);
  return r.success ? { ok: true, data: r.data } : { ok: false, error: r.error };
}
// Reusable, no throwing.

Szybki test: parse a safeParse

Sprawdź swoją wiedzę na temat różnic między parse a safeParse.

Odpowiedz w interaktywnej lekcji

Podsumowanie: parse a safeParse

Dowiedział się Pan lub dowiedziała się Pani, że parse zgłasza wyjątek dla nieprawidłowych danych, a safeParse zwraca wynik z success/error, kiedy używać każdej z metod oraz jak odczytywać problemy z ZodError.

import { z } from "zod";
const schema = z.object({ id: z.number() });
const r = schema.safeParse({ id: 1 });
if (r.success) console.log(r.data.id);

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łatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „parse a safeParse” jest bezpłatna?

Tak — pełny tekst „parse a safeParse” 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 „parse a safeParse”?

Sprawnie obsługuj powodzenie i niepowodzenie walidacji Ć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 3 z 4.

Ile czasu zajmuje lekcja „parse a safeParse”?

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