Servidor HTTP con Express

1.Qué hace un servidor HTTP

Cuando abres una página, tu navegador (el cliente) hace una petición a otra computadora (el servidor) y esta devuelve una respuesta. Eso es HTTP. Con Node puedes escribir tú el servidor: un programa que se queda escuchando en un puerto y responde a cada petición.

Una petición lleva un método (GET, POST…), una ruta (/productos) y a veces un cuerpo con datos. La respuesta lleva un código de estado (200, 404…) y su propio cuerpo.

En tu computadora, el servidor es accesible en http://localhost:3000: localhost significa «esta misma máquina» y 3000 es el puerto (un número entre 1 y 65535 que identifica el programa que escucha).

Node incluye el módulo http para esto, pero hacerlo a mano es tedioso: tendrías que analizar las rutas, leer el cuerpo y poner cabeceras tú mismo. Por eso casi todo el mundo usa un framework. El más extendido es Express.

2.Tu primer servidor con Express

Crea una carpeta, ejecuta npm init -y, añade "type": "module" a package.json (lección 2) e instala Express:

npm install express

Ahora crea index.js:

import express from "express";

const app = express();
const PORT = 3000;

app.get("/", (req, res) => {
  res.send("¡Hola desde Express!");
});

app.listen(PORT, () => {
  console.log(`Servidor en http://localhost:${PORT}`);
});

node --watch index.js

Servidor en http://localhost:3000

Abre http://localhost:3000 en el navegador: verás «¡Hola desde Express!». Detén el servidor con Ctrl + C. Fíjate en las piezas:

1. express() crea la aplicación (app).
2. app.get("/", manejador) dice: «cuando llegue una petición GET a la ruta /, ejecuta esta función».
3. El manejador recibe req (la petición) y res (la respuesta). Con res.send(...) envías el cuerpo.
4. app.listen(PORT, ...) arranca el servidor y lo deja esperando peticiones.

3.Rutas, parámetros y query

Una ruta combina un método HTTP y una dirección. Puedes definir tantas como quieras, y los datos variables llegan por tres sitios:

// 1. Parámetros de ruta: /saludo/Ana
app.get("/saludo/:nombre", (req, res) => {
  res.send(`Hola, ${req.params.nombre}`);
});

// 2. Query string: /suma?a=2&b=3
app.get("/suma", (req, res) => {
  const a = Number(req.query.a);
  const b = Number(req.query.b);
  res.json({ a, b, resultado: a + b });
});

curl http://localhost:3000/saludo/Ana
curl "http://localhost:3000/suma?a=2&b=3"

Hola, Ana
{"a":2,"b":3,"resultado":5}

Los distintos métodos (app.post, app.put, app.delete) se usan igual; los estudiarás a fondo en la lección 5.

4.Responder: send, json y status

El objeto res tiene varios métodos para construir la respuesta. Estos son los que usarás cada día:

El código de estado le dice al cliente cómo fue todo. Por defecto es 200. Los más habituales:

app.get("/producto/:id", (req, res) => {
  const id = Number(req.params.id);

  if (Number.isNaN(id)) {
    return res.status(400).json({ error: "El id debe ser un número" });
  }
  if (id !== 1) {
    return res.status(404).json({ error: "Producto no encontrado" });
  }
  res.json({ id: 1, nombre: "Cuaderno", precio: 12.5 });
});

5.Recibir JSON: express.json()

Cuando un cliente envía datos en el cuerpo de la petición (normalmente con POST), Express no los interpreta por sí solo. Necesitas activar el middleware express.json(), que lee el cuerpo y lo deja convertido en un objeto en req.body:

app.use(express.json());   // antes de las rutas que lo necesiten

app.post("/eco", (req, res) => {
  const { mensaje } = req.body ?? {};

  if (!mensaje) {
    return res.status(400).json({ error: "Falta el campo mensaje" });
  }
  res.status(201).json({ recibido: mensaje });
});

Para probarlo, envía una petición POST con JSON:

curl -X POST http://localhost:3000/eco -H "Content-Type: application/json" -d '{"mensaje":"hola"}'

{"recibido":"hola"}

6.Middleware: funciones en cadena

Un middleware es una función que se ejecuta entre la llegada de la petición y la respuesta final. Recibe req, res y next. Puede mirar o modificar la petición, y luego tiene dos opciones: llamar a next() para pasar al siguiente, o responder y cortar la cadena.

app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next();   // sin esto, la petición se queda colgada
});

Los middlewares se ejecutan en el orden en que los registras. Por eso express.json() debe ir antes de las rutas que usan req.body. Experimenta con la idea en este editor, que simula la cadena en JavaScript puro:

Observa que en /privado el tercer middleware nunca se ejecuta: el segundo respondió y no llamó a next(). Así funcionan la autenticación, el registro, la lectura del cuerpo y casi todo en Express.

Tres middlewares que casi siempre usarás

// 1. Archivos estáticos: sirve lo que haya en la carpeta public/
app.use(express.static("public"));

// 2. Ruta no encontrada (404): va DESPUÉS de todas tus rutas
app.use((req, res) => {
  res.status(404).json({ error: "Ruta no encontrada" });
});

// 3. Manejador de errores: lleva CUATRO parámetros y va al final
app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: "Error interno del servidor" });
});

7.El servidor completo

Juntando todo, este es un servidor pequeño pero completo. Pruébalo, rómpelo y míralo funcionar:

import express from "express";

const app = express();
const PORT = 3000;

app.use(express.json());

app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next();
});

app.get("/", (req, res) => {
  res.send("API en marcha");
});

app.get("/saludo/:nombre", (req, res) => {
  res.json({ mensaje: `Hola, ${req.params.nombre}` });
});

app.get("/suma", (req, res) => {
  const a = Number(req.query.a);
  const b = Number(req.query.b);
  if (Number.isNaN(a) || Number.isNaN(b)) {
    return res.status(400).json({ error: "a y b deben ser números" });
  }
  res.json({ resultado: a + b });
});

app.post("/eco", (req, res) => {
  const { mensaje } = req.body ?? {};
  if (!mensaje) {
    return res.status(400).json({ error: "Falta el campo mensaje" });
  }
  res.status(201).json({ recibido: mensaje });
});

app.use((req, res) => {
  res.status(404).json({ error: "Ruta no encontrada" });
});

app.listen(PORT, () => {
  console.log(`Servidor en http://localhost:${PORT}`);
});

Para saber más sobre todo lo que ofrece, consulta la documentación oficial en expressjs.com.

8.Errores frecuentes

• EADDRINUSE: el puerto ya está ocupado por otro programa o por tu servidor anterior.
• Olvidar next() en un middleware: la petición se queda colgada y el navegador gira sin respuesta.
• Poner express.json() después de las rutas: req.body llega vacío porque el orden importa.
• Responder dos veces (Cannot set headers after they are sent): falta un return tras responder en un caso de error.
• Olvidar reiniciar el servidor tras editar el código. Usa node --watch.
• Tratar req.query y req.params como números: siempre llegan como texto.
• Poner el 404 antes de las rutas: capturaría todas las peticiones. Va al final.

9.Glosario