Fejl-middleware og result-typer
Design en central fejlhåndterer og et typet Result-mønster, pak async-handlers ind for at videresende fejl, og returnér ensartede fejlstrukturer.
Fejl-middleware og result-typer er en gratis TypeScript Academy-lektion på CoddyKit. Dette er lektion 3 af 3. 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 3 lektioner i alt.
Introduktion
Mål: Centralisér fejl under kørsel, og returnér et ensartet JSON-fejlformat. Du opretter en type Result, en wrapper til asynkrone handlere og en robust fejl-middleware.
- Diskrimineret Result<T,E>
- next(err) fra asynkrone handlere
- Ukendte værdier til typede fejl
Result-type
Brug en diskrimineret union til resultater fra funktioner: { ok: true; value } eller { ok: false; error }. Kaldere skal håndtere begge grene.
// 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") }
}Fejlformat
Normalisér unknown til et lille, forudsigeligt fejlformat. Undgå at lække stakspor til klienter.
// 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" } }
}Asynkron wrapper og middleware
Pak enhver asynkron handler ind, så afvisninger kalder next(err). Den afsluttende fejl-middleware formaterer JSON én gang.
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)Ruter og integration
Kombinér validering og fejlhåndtering: validering returnerer 400 med detaljer, mens andre afvisninger fanges af den centrale middleware.
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"))Tips
Tips:
- Log detaljer på serveren, og returnér minimale klientmeddelelser.
- Foretræk en typet Result i tjenester, og oversæt den til HTTP ved kanten.
- Slug aldrig afvisninger op – kald altid
next(err).
Kontrol af asynkrone fejl
Hurtig kontrol: Hvilket mønster videresender asynkrone fejl korrekt?
Opsummering
Opsummering: Brug en Result-union til domænelogik, pak asynkrone handlere ind, så de kalder next, og formatér fejl én gang i en afsluttende middleware.
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 “Fejl-middleware og result-typer” gratis?
Ja — hele teksten til “Fejl-middleware og result-typer” 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 3 lektioner i alt.
Hvad lærer jeg i “Fejl-middleware og result-typer”?
Design en central fejlhåndterer og et typet Result-mønster, pak async-handlers ind for at videresende fejl, og returnér ensartede fejlstrukturer. 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 3 af 3.
Hvor lang tid tager lektionen “Fejl-middleware og result-typer”?
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
- Router handlers, Request/Response-typning
- Skemavalidering med zod og inferens til TS
- Fejl-middleware og result-typer