Jak działa middleware Express?

Question

IT Interview Practice · Accepted Answer

**Middleware** to funkcje, które działają **sekwencyjnie** podczas cyklu request-response w Express. Każdy odbiera `(req, res, next)` i może inspektować/modyfikować żądanie i odpowiedź, zakończyć odpowiedź lub wywołać `next()`, aby przekazać kontrolę następnemu middleware. To jest jądro struktury aplikacji Express.

## Dlaczego to ważne

Middleware to architektoniczny kręgosłup Express (i podobnych frameworków) — uwierzytelnianie, logowanie, body parsing, CORS, walidacja i obsługa błędów to wszystko middleware.

Zrozumienie kontraktu `(req, res, next)` (zwłaszcza że musisz wywołać `next()` lub wysłać odpowiedź), jak middleware może spowodować krótkie spięcie lub wzbogacić żądania, czterech-argumentowy error handler i fakt, że **kolejność ma znaczenie**, jest niezbędne do budowania, strukturyzowania i debugowania dowolnej aplikacji Express.

## Sygnatura i łańcuch

```js
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`); // do something
  next();                                   // ⬅ pass control to the next middleware
});
```

Krytyczna reguła: **wywołaj `next()`**, aby kontynuować łańcuch. Jeśli to zapomnisz (i nie wyślesz odpowiedzi), żądanie będzie wiszące na zawsze.

## Przepływ

```text
Request → [logger] → [auth] → [body parser] → [route handler] → Response
            next()    next()     next()         res.send()
Each middleware runs in order; any can short-circuit by sending a response.
```

## Typowe typy middleware

```js
// 1. Application-level — runs for all (or path-matched) requests
app.use(express.json());                       // built-in: parse JSON bodies
app.use(cors());                                // third-party

// 2. Custom — e.g. authentication that can SHORT-CIRCUIT
function requireAuth(req, res, next) {
  if (!req.headers.authorization) {
    return res.status(401).json({ error: "Unauthorized" }); // STOP — don't call next()
  }
  req.user = decodeToken(req.headers.authorization);  // attach data for later handlers
  next();                                              // authorized → continue
}

// 3. Route-specific
app.get("/profile", requireAuth, (req, res) => res.json(req.user));
```

Middleware może **przerwać** (wysłać odpowiedź i nie wywoływać `next()`, np. blokować nieautoryzowane żądania) lub **wzbogacić** żądanie (dołączając `req.user` dla obsługiwania w dół strumienia).

## Middleware obsługi błędów (cztery argumenty)

```js
// special signature with 4 params → Express treats it as an error handler
app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: "Server error" });
});
// triggered by next(err) or a thrown error; place it LAST
```

Obsługiwacz błędów ma **cztery** parametry (`err` jako pierwszy). Dostęp do niego uzyskuje się przez wywołanie `next(err)`; powinien być zarejestrowany na końcu.

## Kolejność ma znaczenie

```text
Middleware runs in the ORDER you register it. Body parser before routes that
read the body; auth before protected routes; error handler last.
```

Dlaczego to ważne

Sygnatura i łańcuch

Przepływ

Typowe typy middleware

Middleware obsługi błędów (cztery argumenty)

Kolejność ma znaczenie

Powiązane pytania