Comment fonctionne le middleware dans Express ?

Question

IT Interview Practice · Accepted Answer

**Le Middleware** sont des fonctions qui s'exécutent **en séquence** pendant le cycle de requête-réponse dans Express. Chacune reçoit `(req, res, next)` et peut inspecter/modifier la requête et la réponse, terminer la réponse ou appeler `next()` pour passer le contrôle au middleware suivant. C'est le cœur de la structure des applications Express.

## La signature et la chaîne

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

La règle critique : **appelez `next()`** pour continuer la chaîne. Si vous l'oubliez (et n'envoyez pas de réponse), la requête restera bloquée à jamais.

## Le flux

```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.
```

## Types de middleware courants

```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));
```

Le Middleware peut **court-circuiter** (envoyer une réponse et ne pas appeler `next()`, par exemple bloquer les requêtes non autorisées) ou **enrichir** la requête (en joignant `req.user` pour les gestionnaires en aval).

## Middleware de gestion des erreurs (quatre arguments)

```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
```

Un gestionnaire d'erreurs a **quatre** paramètres (`err` en premier). Vous l'atteignez en appelant `next(err)`; il doit être enregistré en dernier.

## L'ordre est important

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

## Pourquoi c'est important

Le Middleware est l'épine dorsale architecturale d'Express (et de cadres similaires) — l'authentification, la journalisation, l'analyse du corps, CORS, la validation et la gestion des erreurs sont tous du middleware.

Comprendre le contrat `(req, res, next)` (en particulier que vous devez appeler `next()` ou envoyer une réponse), comment le middleware peut court-circuiter ou enrichir les requêtes, le gestionnaire d'erreurs à quatre arguments et que **l'ordre est important**, est essentiel pour construire, structurer et déboguer toute application Express.

La signature et la chaîne

Le flux

Types de middleware courants

Middleware de gestion des erreurs (quatre arguments)

L'ordre est important

Pourquoi c'est important

Questions connexes