Fehler-Middleware und Result-Typen
Entwerfen Sie einen zentralen Fehler-Handler und ein typisiertes Result-Muster, leiten Sie Fehler in asynchronen Handlern weiter und geben Sie einheitliche Fehlerobjekte zurück.
Fehler-Middleware und Result-Typen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.
Einführung
Ziel: Zentralisieren Sie Laufzeitfehler und geben Sie ein einheitliches JSON-„Fehlerformat“ zurück. Sie erstellen einen Result-Typ, einen Async-Handler-Wrapper und eine robuste Fehler-Middleware.
- Diskriminierte Result<T,E>
- next(err) aus Async-Handlern
- Zuordnung von Unknown zu typisiertem Fehler
Result-Typ
Verwenden Sie für die Ergebnisse von Funktionen eine diskriminierte Union: { ok: true; value } oder { ok: false; error }. Aufrufer müssen beide Zweige behandeln.
// Result pattern for services and controllers
export type Ok<T> = { ok: true; value: T }
export type Err<E> = { ok: false; error: E }
export type Result<T, E = string> = Ok<T> | Err<E>
export const ok = <T>(value: T): Ok<T> => ({ ok: true, value })
export const err = <E>(error: E): Err<E> => ({ ok: false, error })
// Example usage
async function getUserName(id: string): Promise<Result<string, "NOT_FOUND" | "DB">> {
if (id === "missing") return err("NOT_FOUND")
try { return ok("Ada") } catch { return err("DB") }
}Fehlerformat
Normalisieren Sie unknown zu einem kleinen, vorhersehbaren Fehlerformat. Vermeiden Sie das Durchsickern von Stacktraces an Clients.
// Canonical error envelope
export type ErrorEnvelope = {
error: string
code?: string
details?: unknown
}
export function mapError(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" } }
}Async-Wrapper + Middleware
Umschließen Sie jeden async-Handler, sodass Rejections next(err) aufrufen. Die abschließende Fehler-Middleware formatiert JSON genau einmal.
import express, { Request, Response, NextFunction } from "express"
export const asyncHandler = <P, ResBody, ReqBody, Query>(fn: (req: Request<P, ResBody, ReqBody, Query>, res: Response<ResBody>, next: NextFunction) => Promise<unknown>) => {
return (req: Request<P, ResBody, ReqBody, Query>, res: Response<ResBody>, next: NextFunction) => {
Promise.resolve(fn(req, res, next)).catch(next)
}
}
export function errorMiddleware(err: unknown, _req: Request, res: Response, _next: NextFunction) {
const env = mapError(err)
const status = env.code === "NOT_FOUND" ? 404 : 500
res.status(status).json(env)
}
// Usage
// app.get("/", asyncHandler(async (req, res) => { throw new Error("boom") }))
// app.use(errorMiddleware)Routen + Integration
Kombinieren Sie Validierung und Fehlerbehandlung: Die Validierung gibt 400 mit Details zurück; andere Rejections werden von der zentralen Middleware abgefangen.
import express from "express"
import { z } from "zod"
import { asyncHandler, errorMiddleware } from "./errors"
const createUserSchema = z.object({ name: z.string().min(1) })
const app = express()
app.use(express.json())
app.post("/users", asyncHandler(async (req, res) => {
const parsed = createUserSchema.safeParse(req.body)
if (!parsed.success) {
res.status(400).json({ error: "Invalid body", details: parsed.error.format() })
return
}
res.status(201).json({ id: "u_1", name: parsed.data.name })
}))
app.use(errorMiddleware)
app.listen(3000, () => console.log("http://localhost:3000"))Tipps
Tipps:
- Protokollieren Sie serverseitige Details; geben Sie Clients nur minimale Meldungen zurück.
- Bevorzugen Sie in Services ein typisiertes Result und bilden Sie es am Rand der Anwendung auf HTTP ab.
- Verschlucken Sie niemals Rejections – rufen Sie immer
next(err)auf.
Async-Fehler prüfen
Kurze Prüfung: Welches Muster leitet Async-Fehler korrekt weiter?
Zusammenfassung
Zusammenfassung: Verwenden Sie für die Domänenlogik eine Result-Union, umschließen Sie Async-Handler so, dass sie next aufrufen, und formatieren Sie Fehler genau einmal in einer abschließenden Middleware.
Häufig gestellte Fragen
Ist die Lektion „Fehler-Middleware und Result-Typen“ kostenlos?
Ja — der vollständige Text von „Fehler-Middleware und Result-Typen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „Fehler-Middleware und Result-Typen“?
Entwerfen Sie einen zentralen Fehler-Handler und ein typisiertes Result-Muster, leiten Sie Fehler in asynchronen Handlern weiter und geben Sie einheitliche Fehlerobjekte zurück. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um TypeScript Academy zu starten?
Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 3.
Wie lange dauert die Lektion „Fehler-Middleware und Result-Typen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?
Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Router-Handler, Request-/Response-Typisierung
- Schema-Validierung mit zod und Inferenz nach TS
- Fehler-Middleware und Result-Typen