Parsing difensivo e buste degli errori
Costruisca una gestione robusta delle richieste: esegua il parsing in modo difensivo, mappi tutti gli errori in una compatta busta JSON e impedisca la divulgazione dei dettagli interni.
Parsing difensivo e buste degli errori è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 di 2. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 2 lezioni in totale.
Introduzione
Obiettivo: eseguire il parsing in modo difensivo e rispondere sempre con un envelope JSON degli errori prevedibile. Manterremo la convalida vicino al confine, standardizzeremo gli errori e conserveremo log dettagliati mantenendo minime le risposte.
- safeParse per tutti gli input non attendibili
- { error, code, details? } coerente
- Disciplina tra 4xx e 5xx
Mappatura dell'envelope
Definisca un piccolo ErrorEnvelope riutilizzabile. Mappi gli errori unknown al suo interno senza esporre gli stack trace.
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 validate
Racchiuda gli schemi in un helper validate che restituisca un risultato discriminato. Gli handler rimangono piccoli e coerenti.
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> }
}Handler difensivo
Convalidi subito e restituisca 400 con i dettagli dei problemi. Gli errori imprevisti vengono propagati all'error middleware come 500 con l'envelope.
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)
}Envelope comuni
Fornisca piccoli helper per gli esiti comuni: 404/401 con stringhe code stabili, così i client possono scegliere il comportamento in modo affidabile.
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" } }
}Log e risposta
Bilanci log e risposta: registri lato server l'errore completo (stack, ID della richiesta, ID dell'utente), ma restituisca al client un envelope minimo. Consideri i limiti di frequenza e la redazione dei dati PII.
Verifica pratica dell'envelope
Verifica rapida: come devono essere restituiti gli errori di convalida?
Riepilogo
Riepilogo: convalidi gli input con safeParse, mappi gli errori a un envelope compatto e separi i log dettagliati dalle risposte minime per i client.
Domande Frequenti
La lezione «Parsing difensivo e buste degli errori» è gratuita?
Sì — il testo completo di «Parsing difensivo e buste degli errori» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 2 lezioni in totale.
Cosa imparerò in «Parsing difensivo e buste degli errori»?
Costruisca una gestione robusta delle richieste: esegua il parsing in modo difensivo, mappi tutti gli errori in una compatta busta JSON e impedisca la divulgazione dei dettagli interni. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare TypeScript Academy?
Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 2.
Quanto tempo richiede la lezione «Parsing difensivo e buste degli errori»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?
Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Schemi zod/valibot + inferenza
- Parsing difensivo e buste degli errori