Análisis defensivo y envoltorios de errores
Construya un manejo robusto de solicitudes: analice los datos de forma defensiva, convierta todos los fallos en un envoltorio de error JSON compacto y evite filtrar información interna.
Análisis defensivo y envoltorios de errores es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 de 2. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 2 lecciones en total.
Introducción
Objetivo: analizar la entrada de forma defensiva y responder siempre con un envoltorio de error JSON predecible. Mantenga la validación cerca de la frontera, estandarice los fallos y conserve registros detallados mientras las respuestas son mínimas.
- safeParse para todas las entradas no confiables
- { error, code, details? } coherente
- Disciplina con 4xx frente a 5xx
Mapeador del envoltorio
Defina un ErrorEnvelope pequeño y reutilizable. Asigne los errores unknown a él sin exponer trazas de pila.
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" } }
}Ayudante validate
Envuelva los esquemas en un pequeño ayudante validate que devuelva un resultado discriminado. Los manejadores serán pequeños y coherentes.
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> }
}Manejador defensivo
Valide pronto y devuelva 400 con los detalles de los problemas. Los fallos inesperados se propagan al middleware de errores como un 500 con el envoltorio.
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)
}Envoltorios comunes
Proporcione pequeños ayudantes para resultados habituales: 404/401 con cadenas code estables para que los clientes puedan tomar decisiones de forma fiable.
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" } }
}Registros frente a respuesta
Equilibre los registros y la respuesta: registre el error completo en el servidor (pila, identificador de solicitud e identificador de usuario), pero devuelva al cliente un envoltorio mínimo. Considere los límites de frecuencia y la redacción de PII.
Comprobación práctica del envoltorio
Comprobación rápida: ¿Cómo deben devolverse los errores de validación?
Resumen
Resumen: Valide las entradas con safeParse, asigne los fallos a un envoltorio compacto y separe los registros detallados de las respuestas mínimas para el cliente.
Preguntas frecuentes
¿La lección «Análisis defensivo y envoltorios de errores» es gratis?
Sí — el texto completo de «Análisis defensivo y envoltorios de errores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 2 lecciones en total.
¿Qué aprenderé en «Análisis defensivo y envoltorios de errores»?
Construya un manejo robusto de solicitudes: analice los datos de forma defensiva, convierta todos los fallos en un envoltorio de error JSON compacto y evite filtrar información interna. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar TypeScript Academy?
No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 2.
¿Cuánto tiempo toma la lección «Análisis defensivo y envoltorios de errores»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?
Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Esquemas de zod/valibot e inferencia
- Análisis defensivo y envoltorios de errores