Feilmiddleware og Result-typer
Utform en sentral feilhåndterer og et typet Result-mønster, pakk inn async-behandlere for å videresende feil, og returner konsekvente feilkonvolutter.
Feilmiddleware og Result-typer er en gratis leksjon i TypeScript Academy på CoddyKit. Dette er leksjon 3 av 3. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i TypeScript Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i TypeScript Academy inneholder totalt 3 leksjoner.
Introduksjon
Mål: Sentraliser kjøretidsfeil og returner en konsekvent JSON-«feilkonvolutt». De skal opprette en Result-type, en wrapper for async-handlere og robust feil-middleware.
- Diskriminert Result<T,E>
- next(err) fra async-handlere
- Mapping fra unknown til typet feil
Result-type
Bruk en diskriminert unionstype for funksjonsresultater: { ok: true; value } eller { ok: false; error }. Kallere må håndtere begge grenene.
// 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") }
}Feilkonvolutt
Normaliser unknown til en liten, forutsigbar feilkonvolutt. Unngå å lekke stack traces 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" } }
}Async-wrapper og middleware
Pakk inn enhver async-handler slik at avvisninger kaller next(err). Den endelige feil-middleware-en 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 integrasjon
Kombiner validering og feilhåndtering: Validering returnerer 400 med detaljer, mens andre avvisninger fanges opp av den sentrale middleware-en.
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:
- Logg detaljer på serveren, og returner minimale meldinger til klienten.
- Foretrekk typet Result i tjenester, og gjør om til HTTP ved grensen.
- Sluk aldri avvisninger – kall alltid
next(err).
Kontroll av async-feil
Kort kontroll: Hvilket mønster videresender async-feil korrekt?
Oppsummering
Oppsummering: Bruk en Result-union for domenelogikk, pakk inn async-handlere slik at de kaller next, og formater feil én gang i en endelig middleware.
Lær deg TypeScript med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 101
- Leksjoner
- 352
Ofte stilte spørsmål
Er leksjonen «Feilmiddleware og Result-typer» gratis?
Ja – hele teksten i «Feilmiddleware og Result-typer» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av TypeScript Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i TypeScript Academy inneholder totalt 3 leksjoner.
Hva lærer jeg i «Feilmiddleware og Result-typer»?
Utform en sentral feilhåndterer og et typet Result-mønster, pakk inn async-behandlere for å videresende feil, og returner konsekvente feilkonvolutter. Du øver på TypeScript Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med TypeScript Academy?
Ingen tidligere erfaring er nødvendig. TypeScript Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 3.
Hvor lang tid tar leksjonen «Feilmiddleware og Result-typer»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne TypeScript Academy-leksjonen?
Ja. Alle TypeScript Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Typetilordning av router-behandlere og Request/Response
- Skjemavalidering med zod og inferens til TS
- Feilmiddleware og Result-typer