TypeScript Academy · Lektion

Typisierte Middleware und Error-Handler

Schreiben Sie typsichere Express-Middleware-Funktionen.

Lektion 3 von 413 Schritte

Typisierte Middleware und Error-Handler ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. 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 4 Lektionen.

Willkommen

Typsichere Express-Middleware und Error-Handler verhindern häufige Fehler in Pipelines zur Verarbeitung von Requests.

Middleware-Signatur

Eine Middleware-Funktion erhält req, res und next. Verwenden Sie den RequestHandler-Typ aus express.

import { RequestHandler } from 'express';
const authMiddleware: RequestHandler = (req, res, next) => {
  if (!req.headers.authorization) return res.status(401).json({});
  next();
};

NextFunction

Importieren Sie NextFunction, um den dritten Parameter explizit zu typisieren.

import { Request, Response, NextFunction } from 'express';
function logger(req: Request, res: Response, next: NextFunction): void {
  console.log(req.method, req.path);
  next();
}

Signatur des Error-Handlers

Error-Handler benötigen vier Parameter. TypeScript setzt dies über den Typ ErrorRequestHandler durch.

import { ErrorRequestHandler } from 'express';
const errorHandler: ErrorRequestHandler = (err, req, res, next) => {
  res.status(err.status ?? 500).json({ message: err.message });
};

Benutzerdefinierte Error-Klasse

Definieren Sie eine typisierte Error-Klasse mit einem Statuscode.

class AppError extends Error {
  constructor(public message: string, public status: number = 500) {
    super(message);
  }
}

Wrapper für asynchrone Middleware

Umschließen Sie asynchrone Middleware, um Fehler an den Express-Error-Handler weiterzuleiten.

function asyncHandler(fn: RequestHandler): RequestHandler {
  return (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
}

Auth-Middleware mit Benutzerzuordnung

Fügen Sie den authentifizierten Benutzer nach der Token-Verifizierung dem Request hinzu.

const authenticate: RequestHandler = async (req, res, next) => {
  const user = await verifyToken(req.headers.authorization);
  req.user = user; // requires module augmentation
  next();
};

Validierungs-Middleware mit Zod

Verwenden Sie Zod in Middleware, um Request-Bodies zu parsen und ihre Typen einzugrenzen.

function validate<T>(schema: ZodSchema<T>): RequestHandler {
  return (req, res, next) => {
    const result = schema.safeParse(req.body);
    if (!result.success) return res.status(400).json(result.error);
    req.body = result.data;
    next();
  };
}

Middleware auf Router-Ebene

Wenden Sie typisierte Middleware auf bestimmte Routen an.

router.use('/admin', authenticate, authorize('admin'));
router.get('/admin/users', asyncHandler(listUsers));

Logging-Middleware

Typisierte Middleware zum Protokollieren von Requests.

const requestLogger: RequestHandler = (req, _res, next) => {
  console.log(`${req.method} ${req.path}`);
  next();
};

Globalen Error-Handler registrieren

Registrieren Sie den Error-Handler als letzte Middleware in der Kette.

app.use(requestLogger);
app.use('/api', apiRouter);
app.use(errorHandler); // must be last

Kurztest

Wie viele Parameter hat ein Express-Error-Handler?

Beantworte es in der interaktiven Lektion

Zusammenfassung

Verwenden Sie die Typen RequestHandler, ErrorRequestHandler und NextFunction für Express-Middleware. Umschließen Sie asynchrone Handler, um Fehler weiterzuleiten. Verwenden Sie Zod in Middleware zur typisierten Validierung des Request-Bodies.

Kostenlos starten

Lerne TypeScript mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 101
Lektionen: 352

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Typisierte Middleware und Error-Handler“ kostenlos?

Ja — der vollständige Text von „Typisierte Middleware und Error-Handler“ 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 4 Lektionen.

Was lerne ich in „Typisierte Middleware und Error-Handler“?

Schreiben Sie typsichere Express-Middleware-Funktionen. 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 4.

Wie lange dauert die Lektion „Typisierte Middleware und Error-Handler“?

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

TypeScript mit Node.js einrichten
Express-Request und -Response typisieren
Typisierte Middleware und Error-Handler
Umgebungsvariablen und Konfiguration typisieren

← Zurück zu TypeScript Academy