Defensiv parsing og fejlkontainere
Opbyg robust request-håndtering: pars data defensivt, map alle fejl til en kompakt JSON-fejlkontainer, og undgå at lække interne detaljer.
Defensiv parsing og fejlkontainere er en gratis TypeScript Academy-lektion på CoddyKit. Dette er lektion 2 af 2. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i TypeScript Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. TypeScript Academy-kurset indeholder 2 lektioner i alt.
Introduktion
Mål: Udfør parsing defensivt, og svar altid med en forudsigelig JSON-fejlindpakning. Vi holder valideringen tæt på grænsen, standardiserer fejl og sørger for fyldige logge, mens svarene holdes minimale.
- safeParse på alle input, du ikke har tillid til
- Ensartet { error, code, details? }
- Disciplin for 4xx kontra 5xx
Fejlindpakningsmapper
Definér en lille, genanvendelig ErrorEnvelope. Tilknyt unknown-fejl til den uden at eksponere stack-traces.
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" } }
}Valideringshjælper
Pak skemaer ind i en validate-hjælper, der returnerer et diskrimineret resultat. Behandlerne forbliver små og ensartede.
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> }
}Defensiv behandler
Validér tidligt, og returnér 400 med oplysninger om problemerne. Uventede fejl sendes videre til fejlmiddlewaret som en 500 med fejlindpakningen.
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)
}Almindelige fejlindpakninger
Tilbyd små hjælpere til almindelige resultater: 404/401 med stabile code-strenge, så klienter pålideligt kan vælge gren.
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" } }
}Logning kontra svar
Afvej logning og svar: Log hele fejlen på serversiden (stack, request-id, bruger-id), men returnér en minimal fejlindpakning til klienten. Overvej hastighedsbegrænsninger og maskering af personhenførbare oplysninger.
Kontrol af praksis for fejlindpakning
Hurtig kontrol: Hvordan skal valideringsfejl returneres?
Opsummering
Opsummering: Validér input med safeParse, tilknyt fejl til en kompakt fejlindpakning, og adskil fyldige logge fra minimale klientsvar.
Lær TypeScript med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 101
- Lektioner
- 352
Ofte stillede spørgsmål
Er lektionen “Defensiv parsing og fejlkontainere” gratis?
Ja — hele teksten til “Defensiv parsing og fejlkontainere” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af TypeScript Academy-kurset, skal du opgradere til CoddyKit PRO. TypeScript Academy-kurset indeholder 2 lektioner i alt.
Hvad lærer jeg i “Defensiv parsing og fejlkontainere”?
Opbyg robust request-håndtering: pars data defensivt, map alle fejl til en kompakt JSON-fejlkontainer, og undgå at lække interne detaljer. Du øver dig i TypeScript Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på TypeScript Academy?
Der kræves ingen tidligere erfaring. TypeScript Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 2.
Hvor lang tid tager lektionen “Defensiv parsing og fejlkontainere”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne TypeScript Academy-lektion?
Ja. Alle TypeScript Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- zod/valibot-skemaer + inferens
- Defensiv parsing og fejlkontainere