TypeScript Academy · Oppitunti

Virheiden middleware ja Result-tyypit

Suunnitelkaa keskitetty virheenkäsittelijä ja tyypitetty Result-rakenne, välittäkää asynkronisten käsittelijöiden virheet eteenpäin ja palauttakaa yhdenmukaiset virhekuoret.

Oppitunti 3/38 vaihetta

Virheiden middleware ja Result-tyypit on ilmainen TypeScript Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/3. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu TypeScript Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. TypeScript Academy-kurssilla on yhteensä 3 oppituntia.

Johdanto

Tavoite: Keskittäkää ajonaikaiset virheet ja palauttakaa yhdenmukainen JSON-”virhekuori”. Luotte Result-tyypin, asynkronisen käsittelijän käärefunktion ja vankan virhemiddleware-ratkaisun.

Erotteleva Result<T,E>
next(err) asynkronisista käsittelijöistä
unknown→tyypitetyn virheen muunnos

Result-tyyppi

Käyttäkää funktion tuloksissa erottelevaa unionityyppiä: { ok: true; value } tai { ok: false; error }. Kutsujien on käsiteltävä molemmat haarat.

// 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") }
}

Virhekuori

Normalisoikaa unknown pieneksi ja ennakoitavaksi kuoreksi. Älkää vuotako pinojäljityksiä asiakkaille.

// 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" } }
}

Asynkroninen wrapper + middleware

Käärikää mikä tahansa async-käsittelijä niin, että hylkäykset kutsuvat next(err)-funktiota. Lopullinen virhemiddleware muotoilee JSONin kerran.

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)

Reitit + integraatio

Yhdistäkää validointi ja virheenkäsittely: validointi palauttaa 400:n tietojen kera; muut hylkäykset ohjautuvat keskitetyn middlewaren käsiteltäviksi.

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"))

Vinkkejä

Vinkkejä:

Kirjatkaa palvelimen yksityiskohdat; palauttakaa asiakkaalle vain lyhyet viestit.
Suosikaa tyypitettyä Result-tyyppiä toimialalogiikassa ja muuntakaa se HTTP-muotoon rajalla.
Älkää koskaan nielkö hylkäyksiä – kutsukaa aina next(err).

Asynkronisten virheiden tarkistus

Pikatarkistus: Mikä kaava välittää asynkroniset virheet oikein?

Vastaa interaktiivisessa oppitunnissa

Kertaus

Kertaus: Käyttäkää Result-unionityyppiä toimialalogiikassa, käärikää asynkroniset käsittelijät kutsumaan next-funktiota ja muotoilkaa virheet kerran viimeisessä middleware-käsittelijässä.

Aloita maksutta

Opi TypeScript tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 101
Oppitunnit: 352

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Virheiden middleware ja Result-tyypit” ilmainen?

Kyllä – oppitunnin ”Virheiden middleware ja Result-tyypit” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko TypeScript Academy-kurssin, päivitä CoddyKit PROhon. TypeScript Academy-kurssilla on yhteensä 3 oppituntia.

Mitä opin oppitunnilla ”Virheiden middleware ja Result-tyypit”?

Suunnitelkaa keskitetty virheenkäsittelijä ja tyypitetty Result-rakenne, välittäkää asynkronisten käsittelijöiden virheet eteenpäin ja palauttakaa yhdenmukaiset virhekuoret. Harjoittelet TypeScript Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni TypeScript Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin TypeScript Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/3.

Kuinka kauan ”Virheiden middleware ja Result-tyypit”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä TypeScript Academy-oppitunnilla?

Kyllä. Jokainen TypeScript Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Reitittimien käsittelijät ja Request/Response-tyypitys
Skeemavalidointi zodilla ja tyypin päättely TypeScriptiin
Virheiden middleware ja Result-tyypit

← Takaisin: TypeScript Academy