0Pricing
TypeScript Academy · Lekcja

Defensywne parsowanie i koperty błędów

Zbudujcie odporne przetwarzanie żądań: parsujcie dane defensywnie, mapujcie wszystkie błędy na zwięzłą kopertę błędu JSON i unikajcie ujawniania szczegółów wewnętrznych.

Defensywne parsowanie i koperty błędów to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 2 z 2. 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 2 lekcji w sumie.

Wprowadzenie

Cel: Wykonuj analizowanie danych defensywnie i zawsze odpowiadaj przewidywalną kopertą błędu w formacie JSON. Walidację będziemy przeprowadzać blisko granicy systemu, standaryzować błędy i zachowywać szczegółowe logi przy minimalnych odpowiedziach.

  • safeParse dla wszystkich niezaufanych danych wejściowych
  • Spójne { error, code, details? }
  • Rozróżnianie 4xx i 5xx

Mapowanie koperty błędu

Zdefiniuj niewielką, wielokrotnego użytku strukturę ErrorEnvelope. Mapuj błędy typu unknown na tę strukturę, nie ujawniając śladów stosu.

export type ErrorEnvelope = { error: string; code?: string; details?: unknown }

export function toEnvelope(u: unknown): ErrorEnvelope {
  if (u instanceof Error) return { error: u.message }
  if (typeof u === "string") return { error: u }
  try { return { error: JSON.stringify(u) } } catch { return { error: "Unknown error" } }
}

Helper walidacji

Opakuj schematy w helperze validate, który zwraca rozróżnialny wynik. Handlery pozostają małe i spójne.

import { z, type ZodTypeAny } from "zod"

export function validate<T extends ZodTypeAny>(schema: T, value: unknown) {
  const r = schema.safeParse(value)
  if (!r.success) {
    return { ok: false as const, issues: r.error.format() }
  }
  return { ok: true as const, data: r.data as z.infer<T> }
}

Defensywny handler

Waliduj dane wcześnie i zwracaj 400 ze szczegółami problemów. Nieoczekiwane błędy przekazuj do middleware obsługi błędów jako 500 z kopertą błędu.

import type { Request, Response, NextFunction } from "express"
import { z } from "zod"
import { validate } from "./validate"
import { toEnvelope, type ErrorEnvelope } from "./envelope"

const bodySchema = z.object({ email: z.string().email(), newsletter: z.boolean().default(false) })

export function subscribe(req: Request, res: Response<{ ok: true } | ErrorEnvelope>, next: NextFunction) {
  const r = validate(bodySchema, req.body)
  if (!r.ok) return res.status(400).json({ error: "Invalid body", details: r.issues })
  try {
    // pretend to persist
    return res.status(201).json({ ok: true })
  } catch (e) {
    return next(e)
  }
}

export function errorMiddleware(err: unknown, _req: Request, res: Response<ErrorEnvelope>, _next: NextFunction) {
  const env = toEnvelope(err)
  res.status(500).json(env)
}

Typowe koperty błędów

Udostępnij niewielkie helpery dla typowych wyników: 404/401 ze stabilnymi ciągami znaków w code, aby klienci mogli niezawodnie reagować na różne przypadki.

export function notFound(resource: string): { status: 404; body: { error: string; code: string } } {
  return { status: 404, body: { error: `${resource} not found`, code: "NOT_FOUND" } }
}

export function unauthorized(): { status: 401; body: { error: string; code: string } } {
  return { status: 401, body: { error: "unauthorized", code: "UNAUTHORIZED" } }
}

Logi a odpowiedź

Zachowaj równowagę między logami a odpowiedzią: rejestruj pełny błąd po stronie serwera (stos wywołań, identyfikator żądania, identyfikator użytkownika), ale zwracaj klientowi minimalną kopertę. Uwzględnij limity zapytań i anonimizowanie danych PII.

Sprawdzenie koperty błędu

Szybkie sprawdzenie: Jak należy zwracać błędy walidacji?

Podsumowanie

Podsumowanie: Waliduj dane wejściowe za pomocą safeParse, mapuj błędy na zwięzłą kopertę i oddzielaj szczegółowe logi od minimalnych odpowiedzi dla klienta.

Często zadawane pytania

Czy lekcja „Defensywne parsowanie i koperty błędów” jest bezpłatna?

Tak — pełny tekst „Defensywne parsowanie i koperty błędó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 2 lekcji w sumie.

Co nauczysz się w „Defensywne parsowanie i koperty błędów”?

Zbudujcie odporne przetwarzanie żądań: parsujcie dane defensywnie, mapujcie wszystkie błędy na zwięzłą kopertę błędu JSON i unikajcie ujawniania szczegółów wewnętrznych. Ć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 2.

Ile czasu zajmuje lekcja „Defensywne parsowanie i koperty błędó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

  1. Schematy zod/valibot i inferencja
  2. Defensywne parsowanie i koperty błędów
← Powrót do TypeScript Academy