3.1Express : routes, middlewares, requêtes/réponses
Express est le framework web de référence pour Node — de loin le plus utilisé, minimaliste, flexible, et le socle de l'immense majorité des applications et API Node. Il ne réinvente pas Node : il s'appuie SUR le module http (section 2-4) et lui ajoute une couche élégante qui simplifie radicalement le développement web. Là où le serveur natif exigeait de router à la main (cascade de if), de parser le corps manuellement, de gérer les en-têtes un par un, Express offre un routage propre, un système de middlewares puissant, et des objets req/res enrichis. Créer un serveur Express de base tient en quelques lignes : const app = express(); app.listen(3000);. La différence avec le natif se voit immédiatement sur le routage.
Le routage Express associe des URL et des méthodes HTTP à des fonctions de traitement (handlers). app.get('/users', handler) répond aux GET sur /users ; app.post('/users', handler) aux POST ; et de même pour put, delete, patch. Le handler reçoit req (requête, enrichie : req.params pour les paramètres de route, req.query pour la query string, req.body pour le corps) et res (réponse, enrichie : res.json(data) envoie du JSON en une méthode, res.status(201).json(...) définit le statut et envoie, res.send(...), res.redirect(...)). Les paramètres de route : app.get('/users/:id', ...) capture l'id dans req.params.id — pour des URL dynamiques. Le concept le PLUS important d'Express est le middleware : une fonction qui s'exécute AU MILIEU du traitement d'une requête, entre sa réception et la réponse. Un middleware reçoit (req, res, next) et peut : inspecter/modifier req et res, exécuter du code (journaliser, authentifier, valider), puis appeler next() pour passer au middleware suivant (ou envoyer une réponse pour arrêter la chaîne). Les middlewares s'enchaînent en un « pipeline » que chaque requête traverse. Ils sont partout : express.json() (middleware natif qui parse le corps JSON — résout le pénible parsing manuel du natif), express.static() (servir des fichiers statiques, section 3-2), des middlewares de logging, d'authentification (section 4-2), de gestion d'erreurs (section 4-4), et vos propres middlewares. On les applique globalement (app.use(middleware)) ou par route. Comprendre le middleware — cette idée d'un pipeline de fonctions que la requête traverse, chacune pouvant agir et passer la main avec next() — est LA clé d'Express : tout s'y organise (routage, parsing, auth, erreurs sont des middlewares). Express est ainsi à la fois simple à démarrer et puissant à structurer, ce qui explique sa domination. Le maîtriser (routage, req/res enrichis, middlewares) est le cœur du développement web Node, et le socle de tout ce qui suit (API, auth, bases de données).
Vocabulaire de la section
- Express
- Framework web de référence pour Node (minimaliste, flexible), bâti sur le module http ; simplifie routage, parsing et gestion des requêtes. Socle de la plupart des apps Node.
- Routage
- Association d'URL + méthode HTTP à des handlers : app.get('/users', ...), app.post(...), etc. Paramètres de route dynamiques : '/users/:id' → req.params.id.
- req / res enrichis
- req : req.params (route), req.query (query string), req.body (corps). res : res.json(data), res.status(201).json(...), res.send, res.redirect.
- Middleware
- Fonction (req, res, next) s'exécutant pendant le traitement d'une requête ; peut inspecter/modifier, exécuter du code, puis next() pour passer au suivant. LE concept clé d'Express.
- Pipeline de middlewares
- Chaîne de fonctions que chaque requête traverse ; routage, parsing (express.json), auth, gestion d'erreurs sont tous des middlewares (app.use ou par route).
Qu'est-ce qu'un MIDDLEWARE, le concept central d'Express ?
En pratique — Construire une application avec Express
- Créez une app Express (`const app = express()`), ajoutez `app.use(express.json())` pour parser le JSON, et démarrez avec `app.listen(3000)`.
- Définissez des routes : `app.get('/users', ...)`, `app.post('/users', ...)`, et une route dynamique `app.get('/users/:id', ...)` (lisez `req.params.id`).
- Renvoyez des réponses avec les méthodes enrichies : `res.json(data)`, `res.status(201).json(...)`, et lisez le corps avec `req.body`.
- Écrivez votre propre middleware (req, res, next) qui journalise chaque requête, appliquez-le avec `app.use(...)` et appelez `next()`.
Points clés à retenir
- EXPRESS = framework web de référence de Node (bâti sur http) : simplifie radicalement le routage, le parsing et la gestion des requêtes. Socle de la plupart des apps Node.
- ROUTAGE : `app.get/post/put/delete('/chemin', handler)` ; routes dynamiques `/users/:id` → `req.params.id`. req enrichi (params, query, body), res enrichi (res.json, res.status).
- Le MIDDLEWARE (fonction `(req, res, next)`) est LE concept clé : il s'exécute pendant le traitement, agit sur req/res, puis `next()` passe au suivant — un PIPELINE que chaque requête traverse.
- Tout est middleware : `express.json()` (parse le corps), static, auth, gestion d'erreurs, vos propres middlewares (app.use ou par route). Maîtriser Express = cœur du dev web Node.
Questions fréquentes
Qu'est-ce qu'un middleware exactement, et pourquoi est-ce le concept central d'Express ?
Le middleware est LE concept qui définit Express et lui donne sa puissance et sa flexibilité — le comprendre, c'est comprendre Express. Voici une explication complète. Ce qu'est un middleware : une FONCTION qui s'exécute PENDANT le traitement d'une requête, entre le moment où la requête arrive et le moment où la réponse est envoyée. Sa signature : (req, res, next) — elle reçoit la requête (req), la réponse (res), et une fonction spéciale next. Ce qu'un middleware peut FAIRE : (1) INSPECTER la requête (lire req.headers, req.body, req.url…) ; (2) MODIFIER req ou res (ajouter des informations, par exemple attacher l'utilisateur authentifié à req.user) ; (3) EXÉCUTER du code (journaliser, vérifier, valider, mesurer) ; (4) DÉCIDER de la suite : soit appeler next() pour passer au middleware suivant (continuer le pipeline), soit ENVOYER une réponse (res.json, res.status...) pour ARRÊTER la chaîne (par exemple, un middleware d'authentification qui renvoie 401 si l'utilisateur n'est pas connecté, sans aller plus loin). L'idée du PIPELINE : Express traite chaque requête en la faisant passer à travers une CHAÎNE de middlewares, dans l'ordre. La requête « traverse » le pipeline : middleware 1, puis (si next() est appelé) middleware 2, puis 3... jusqu'à ce qu'un middleware envoie la réponse. C'est comme une chaîne de montage où chaque poste (middleware) peut agir sur la requête et décider de passer au suivant ou de terminer. Pourquoi c'est SI puissant et central : (1) TOUT dans Express est middleware. Le parsing du corps JSON (express.json()), le service de fichiers statiques (express.static()), l'authentification, la journalisation, la gestion d'erreurs, la validation, le CORS — ce sont tous des middlewares. Même vos handlers de route sont des middlewares (le dernier de la chaîne pour cette route). Cette UNIFORMITÉ (tout est middleware) rend Express cohérent et extensible : ajouter une fonctionnalité = ajouter un middleware. (2) Réutilisabilité et modularité. Un middleware encapsule une préoccupation (authentifier, valider, journaliser) de façon réutilisable : vous l'écrivez une fois et l'appliquez où vous voulez (à toutes les routes via app.use(), ou à des routes spécifiques). Par exemple, un middleware d'authentification protège toutes les routes où vous l'appliquez, sans dupliquer la logique. (3) Séparation des préoccupations. Chaque middleware fait UNE chose (parser, authentifier, valider…), et on les COMPOSE. Votre logique métier (dans le handler) reste propre, débarrassée des préoccupations transversales (déléguées aux middlewares en amont). C'est une architecture élégante. (4) Ordre et contrôle. L'ORDRE des middlewares compte (ils s'exécutent dans l'ordre d'ajout) — ce qui vous donne un contrôle précis (parser le corps AVANT de le valider, authentifier AVANT d'autoriser l'accès, etc.). Et un middleware peut court-circuiter la chaîne (renvoyer une réponse sans appeler next) — par exemple bloquer une requête non authentifiée. (5) Écosystème. Une multitude de middlewares tiers existent (sécurité avec Helmet, logging avec Morgan, upload avec Multer, etc.) — vous les « branchez » dans votre pipeline. Exemples concrets de middlewares : (1) app.use(express.json()) : parse le corps JSON et le met dans req.body (résout le parsing manuel pénible du natif). (2) Un middleware de LOGGING : journalise chaque requête (méthode, URL, temps) puis next(). (3) Un middleware d'AUTHENTIFICATION : vérifie le jeton, attache req.user, puis next() — ou renvoie 401 si invalide (arrêt). (4) Un middleware de GESTION D'ERREURS (spécial, avec 4 paramètres (err, req, res, next)) : attrape les erreurs et renvoie une réponse d'erreur propre (section 4-4). Le next() et la gestion des erreurs : appeler next() passe au middleware suivant ; appeler next(erreur) (avec un argument) saute directement au middleware de gestion d'erreurs. C'est le mécanisme de propagation des erreurs dans Express. En résumé : le middleware est une fonction qui agit sur la requête pendant son traitement, dans un pipeline que la requête traverse ; c'est le concept central d'Express parce que TOUT y est middleware (uniformité), ce qui rend le framework modulaire, extensible, et élégant à structurer. Comprendre le middleware (agir + next() ou répondre, dans un pipeline ordonné), c'est comprendre comment on architecture une application Express — le cœur de la compétence Express. Une fois ce modèle mental acquis, tout Express devient clair : ce n'est qu'une composition de middlewares.
Pourquoi Express est-il si populaire, et existe-t-il des alternatives à connaître ?
Express domine l'écosystème Node pour de bonnes raisons, mais des alternatives existent — comprendre pourquoi Express est le choix par défaut, et connaître le paysage, vous aide à faire des choix éclairés. Pourquoi Express est si populaire : (1) Minimaliste et non-opinioné. Express fait peu de choses imposées : il fournit le routage et les middlewares, et vous laisse libre de structurer votre application comme vous voulez, de choisir vos outils (base de données, validation, etc.). Cette flexibilité plaît : vous n'êtes pas enfermé dans une façon de faire. (2) Simple à apprendre et à démarrer. Un serveur Express de base tient en quelques lignes ; les concepts (routage, middleware) sont simples et cohérents. On est productif rapidement. (3) Mature et éprouvé. Express existe depuis longtemps, il est stable, extrêmement utilisé en production par d'innombrables applications — un choix sûr et fiable. (4) Écosystème gigantesque. Une multitude de middlewares et de ressources gravitent autour d'Express (sécurité, auth, upload, logging…) — pour presque tout besoin, un middleware existe. (5) Communauté immense. Documentation, tutoriels, réponses de forums, exemples : tout abonde. Un problème rencontré a presque toujours été résolu et documenté. (6) Standard de facto. Express est LE framework qu'on attend qu'un développeur Node connaisse ; le connaître est quasi indispensable professionnellement. Ces atouts (flexibilité, simplicité, maturité, écosystème, communauté) expliquent sa domination durable. Les LIMITES d'Express (qui motivent des alternatives) : (1) son minimalisme signifie que vous devez faire beaucoup de choix et de câblage vous-même (structure, validation, etc.) — une liberté qui est aussi une charge sur les gros projets. (2) Il n'impose pas de structure — sur une grosse application, sans discipline, cela peut mener à du désordre. (3) Certaines fonctionnalités modernes (support natif d'async/await dans la gestion d'erreurs, typage) sont moins intégrées que dans des frameworks plus récents. Les ALTERNATIVES à connaître (au moins de nom) : (1) Fastify : un framework plus récent, axé PERFORMANCE (plus rapide qu'Express) et avec une meilleure intégration moderne (validation de schémas intégrée, bon support TypeScript, async/await natif). De plus en plus populaire, souvent présenté comme un « Express moderne et rapide ». (2) Koa : créé par l'équipe d'Express, plus minimaliste encore, basé sur async/await, avec une approche middleware différente (plus moderne). (3) NestJS : un framework plus STRUCTURÉ et « opinioné » (à la Angular), avec une architecture imposée (modules, injection de dépendances, décorateurs), TypeScript par défaut — apprécié pour les grosses applications d'entreprise qui veulent une structure forte. Il peut d'ailleurs tourner SUR Express ou Fastify. (4) Hapi, et d'autres. Comment choisir : (1) Pour APPRENDRE et pour la plupart des projets → Express reste l'excellent choix par défaut (simple, standard, énorme communauté, compétence attendue). Commencez par lui. (2) Pour la PERFORMANCE et une intégration moderne → Fastify est une alternative sérieuse. (3) Pour une grosse application d'entreprise voulant une STRUCTURE imposée et TypeScript → NestJS. (4) Les CONCEPTS sont largement transférables : le routage, les middlewares, req/res, HTTP — maîtrisés sur Express, ils se transposent aux autres frameworks (qui partagent ces idées avec des variations). Recommandation : (1) APPRENEZ Express (le standard, le socle, la compétence attendue) — c'est ce que fait ce guide, et c'est le bon point de départ. (2) SACHEZ que des alternatives existent (Fastify pour la perf, NestJS pour la structure) — pour ne pas être surpris et pour choisir selon le contexte plus tard. (3) Concentrez-vous sur les CONCEPTS (routage, middlewares, HTTP, API REST) qui transcendent le framework — ils vous rendent adaptable à n'importe lequel. En résumé : Express est populaire car simple, flexible, mature, avec un écosystème et une communauté immenses — c'est le choix par défaut et la compétence de base à avoir. Des alternatives (Fastify, Koa, NestJS) existent pour des besoins spécifiques (performance, structure), et les concepts se transfèrent. Apprenez Express d'abord (le socle) ; explorez les alternatives selon vos besoins et votre curiosité ensuite. Ne vous dispersez pas au début : maîtriser Express vous donne l'essentiel du développement web Node et une base transférable.