3.1Express : rutas, middlewares, peticiones y respuestas
Lo esencial en 30 segundos
- Express afina el módulo http : enrutado limpio (app.get/post/put/delete), parámetros dinámicos (/users/:id → req.params.id), respuestas en una línea (res.json).
- El middleware es el concepto clave : una función (req, res, next) que atraviesa cada petición ; actúa y luego llama a next() o responde para detener la cadena.
- El orden de la cadena importa : primero el analizador (express.json()), luego validar y autenticar, responder al final con el estado correcto.
Mini-caso hilado — Salim sustituye su cascada de if por Express
Salim, desarrollador junior en Argel, sirve un minicatálogo con el módulo http nativo : una cascada de if sobre req.url y req.method, un cuerpo POST analizado a mano, cabeceras colocadas una por una. Lo reescribe todo con Express : app.use(express.json()) para analizar el cuerpo, app.get('/produits/:id') para las fichas dinámicas, un middleware que registra cada petición, res.status(201).json() para las creaciones. Mismo servidor, código tres veces más legible.
Este mismo caso vuelve en el curso, el esquema, el guion y el reto 48h.
1. Enrutado y req/res enriquecidos
Express es el framework web de referencia de Node : minimalista, flexible, construido sobre el módulo http (sección 2-4). El enrutado asocia un método HTTP y una URL a un manejador : app.get('/users', handler), app.post('/users', handler), e igual para put, patch y delete. Las rutas dinámicas capturan segmentos : app.get('/users/:id') deja el identificador legible en req.params.id.
Los objetos están enriquecidos respecto al nativo. Lado petición : req.params (parámetros de ruta), req.query (query string tras el ?), req.body (cuerpo analizado, disponible gracias a express.json()). Lado respuesta : res.json(data) envía JSON en un método, res.status(201).json(...) fija el estado y luego envía, res.send y res.redirect cubren los demás casos. Salim gana lo esencial : se acabó el análisis manual, rutas legibles, respuestas explícitas.
2. El middleware : una cadena donde el orden importa
El middleware es EL concepto clave de Express : una función (req, res, next) que se ejecuta durante el tratamiento de una petición. Puede inspeccionar o modificar req y res (adjuntar req.user tras la autenticación), ejecutar código (registrar, validar, medir), y luego llamar a next() para pasar al middleware siguiente — o enviar una respuesta para detener la cadena (por ejemplo devolver 401 sin ir más lejos).
Cada petición atraviesa una cadena en el orden de declaración : express.json() que analiza el cuerpo, vuestros middlewares (log, auth, validación), y luego el manejador final que responde. Todo es middleware : análisis, archivos estáticos, auth, gestión de errores. Dos reflejos de Salim : analizar antes de validar (si no, req.body está vacío) y llamar siempre a next() o responder (si no, la petición queda bloqueada). Se aplica un middleware globalmente (app.use(...)) o sobre una ruta concreta.
El eslabón perdido
Un middleware que no cede la mano bloquea a todo el mundo.
🔎 Ejemplo concreto — Una mini-API de catálogo en pocas líneas
Salim reescribe su servidor nativo con Express.
const express = require('express');
const app = express();
app.use(express.json());
app.use((req, res, next) => { console.log(req.method, req.url); next(); });
app.get('/produits/:id', (req, res) => res.json({ id: req.params.id }));
app.post('/produits', (req, res) => res.status(201).json(req.body));
app.listen(3000);Lectura : el registrador llama a next(), la ruta dinámica lee req.params, la creación devuelve 201.
Lección : el análisis automático elimina todo el código manual del servidor nativo.
Vocabulario de la sección
- Express
- Framework web minimalista de referencia para Node, construido sobre el módulo http ; aporta enrutado, middlewares y req/res enriquecidos.
Ejemplo sencillo: Salim reescribe en él su catálogo en pocas líneas legibles.
Lo que no es: un sustituto de Node que prescindiera del módulo http.
Reflejo: usarlo para toda API o app web en vez del nativo en bruto.
- Enrutado
- Asociación de un método HTTP y una URL a un manejador : app.get('/users', ...), app.post(...), con rutas dinámicas '/users/:id'.
Ejemplo sencillo: GET /produits/7 capturado por app.get('/produits/:id').
Lo que no es: una cascada de if sobre req.url en un servidor nativo.
Reflejo: una ruta por intención, con el verbo HTTP correcto.
- Middleware
- Función (req, res, next) ejecutada durante el tratamiento ; actúa sobre req/res y luego llama a next() o envía una respuesta.
Ejemplo sencillo: El registrador de Salim que anota cada petición y luego cede la mano.
Lo que no es: una simple función utilitaria nunca conectada a la cadena.
Reflejo: terminar siempre con next() o con una respuesta.
- Cadena de middlewares
- Cadena ordenada de middlewares que atraviesa cada petición : análisis, log, auth, validación, manejador final.
Ejemplo sencillo: express.json() luego validación luego manejador en casa de Salim.
Lo que no es: manejadores aislados sin orden ni reparto.
Reflejo: analizar primero, validar después, responder al final.
- req / res enriquecidos
- Objetos Express : req.params, req.query, req.body lado petición ; res.json, res.status, res.send, res.redirect lado respuesta.
Ejemplo sencillo: req.params.id leído y res.status(201).json() devuelto.
Lo que no es: el req/res en bruto del módulo http sin ayuda.
Reflejo: leer el cuerpo en req.body, responder con res.json().
En la práctica — Construir una aplicación con Express
- Cread una app Express (const app = express()), añadid app.use(express.json()) para analizar el JSON, y arrancad con app.listen(3000).
- Definid rutas : app.get('/users', ...), app.post('/users', ...), y una ruta dinámica app.get('/users/:id', ...) (leed req.params.id).
- Devolved respuestas con los métodos enriquecidos : res.json(data), res.status(201).json(...), y leed el cuerpo con req.body.
- Escribid vuestro propio middleware (req, res, next) que registre cada petición, aplicadlo con app.use(...) y llamad a next().
Guion listo para decir — presentar su API Express (30 s)
« Monté la API del catálogo con Express : express.json para analizar el cuerpo, una ruta dinámica /produits/:id leída en req.params, un middleware que registra y luego llama a next, y respuestas res.json con el estado correcto, 201 para las creaciones. Probado en el navegador en localhost:3000. »
Para decir en revisión ; mostrar la ruta dinámica y el log de una petición.
Modelo copiar-pegar — servidor Express mínimo
const express = require('express');
const app = express();
app.use(express.json());
app.use((req, res, next) => {
console.log(req.method, req.url);
next();
});
app.get('/produits/:id', (req, res) => {
res.json({ id: req.params.id });
});
app.post('/produits', (req, res) => {
res.status(201).json(req.body);
});
app.listen(3000, () => console.log('OK port 3000'));Independiente
Una API de presupuestos en Express basta : dos rutas GET/POST y un middleware de log, sin framework pesado.
Pyme en Argel
Salim expone el catálogo interno : rutas dinámicas por referencia de producto, estados 200/201/404 respetados.
Equipo de producto
Estandarizar la cadena (json, log, auth, validación) para que cada ruta herede la misma base.
Principiante
Esta semana : un solo servidor, una ruta GET dinámica y un middleware que llama a next().
✓ Buenas prácticas
- Pensar « cadena » : todo es middleware, el orden importa.
- Usar express.json() para analizar el cuerpo, y res.json() para responder.
- Encapsular las preocupaciones transversales (auth, log) en middlewares reutilizables.
✗ Errores frecuentes
- Olvidar llamar a next() (la petición queda bloqueada).
- Ordenar mal los middlewares (validar antes de analizar).
- Meter toda la lógica en un solo manejador en vez de componer middlewares.
Puntos clave
- EXPRESS = framework web de referencia de Node (construido sobre http) : simplifica enrutado, análisis y gestión de peticiones.
- ENRUTADO : app.get/post/put/delete('/ruta', handler) ; rutas dinámicas /users/:id → req.params.id.
- El MIDDLEWARE (req, res, next) es EL concepto clave : actúa durante el tratamiento, luego next() pasa al siguiente — una CADENA.
- Todo es middleware : express.json(), static, auth, gestión de errores, vuestros propios middlewares (app.use o por ruta).
Reto 48h — aplica mañana
Montad 1 API Express con 1 ruta dinámica y 1 middleware de log que llame a next().
- Cito el papel de next() sin dudar.
- Leo req.params, req.query y req.body.
- Mi API responde res.json() con el estado correcto.
Preguntas frecuentes
¿Qué es exactamente un middleware, y por qué es el concepto central de Express?
Un middleware es una función (req, res, next) que se ejecuta durante el tratamiento de una petición. Puede inspeccionar la petición, modificar req/res (por ejemplo adjuntar req.user), ejecutar código (registrar, validar), y luego decidir : llamar a next() para pasar al siguiente, o enviar una respuesta para detener la cadena (un middleware de auth que devuelve 401). Es central porque todo es middleware en Express : análisis (express.json()), estático, auth, validación, gestión de errores — y vuestros manejadores de ruta son el último eslabón. Pensar « cadena ordenada » en vez de « funciones aisladas », eso es entender Express.
¿Por qué Express es tan popular, y existen alternativas?
Minimalista y no opinado (enrutado + middlewares, libertad de estructura), fácil de arrancar, maduro y probado, ecosistema inmenso de middlewares y estándar de facto esperado de un desarrollador Node. Sus límites (decisiones por tomar uno mismo, sin estructura impuesta) motivan alternativas como Fastify, Koa o NestJS en los grandes proyectos. Pero para aprender y luego producir rápido, Express sigue siendo la opción por defecto — la que Salim domina primero en Argel.
En un middleware Express, ¿qué impone el contrato (req, res, next)?