El servidor más pequeño
import http from "node:http";
const servidor = http.createServer((req, res) => {
res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
res.end(`Hola desde ${req.url}`);
});
servidor.listen(3000, () => console.log("http://localhost:3000"));
La función se ejecuta una vez por petición. req (la petición) trae method, url y headers; res (la respuesta) se escribe con writeHead (estado y encabezados) y end (el cuerpo, y termina).
Rutas y JSON
Para decidir qué responder, mira el método y la ruta:
import http from "node:http";
const tareas = [{ id: 1, titulo: "Estudiar Node", hecha: false }];
function json(res, estado, datos) {
res.writeHead(estado, { "Content-Type": "application/json" });
res.end(JSON.stringify(datos));
}
async function leerJSON(req) {
let cuerpo = "";
for await (const parte of req) cuerpo += parte; // req es un stream
return JSON.parse(cuerpo || "{}");
}
http.createServer(async (req, res) => {
const url = new URL(req.url, `http://${req.headers.host}`);
try {
if (req.method === "GET" && url.pathname === "/tareas") {
return json(res, 200, tareas);
}
if (req.method === "POST" && url.pathname === "/tareas") {
const { titulo } = await leerJSON(req);
if (!titulo) return json(res, 400, { error: "falta el título" });
const tarea = { id: tareas.length + 1, titulo, hecha: false };
tareas.push(tarea);
return json(res, 201, tarea);
}
const coincide = url.pathname.match(/^\/tareas\/(\d+)$/);
if (req.method === "GET" && coincide) {
const tarea = tareas.find((t) => t.id === Number(coincide[1]));
return tarea ? json(res, 200, tarea) : json(res, 404, { error: "no existe" });
}
json(res, 404, { error: "ruta desconocida" });
} catch (e) {
json(res, 500, { error: "error interno" }); // nunca envíes el detalle del error al cliente
}
}).listen(3000);
Cada rama termina con return: una petición tiene una sola respuesta. Pruébalo desde otra terminal:
curl http://localhost:3000/tareas
curl -X POST -H "Content-Type: application/json" -d '{"titulo":"Practicar"}' http://localhost:3000/tareas
Los estados que más se usan
| Estado | Significa |
|---|---|
| 200 OK / 201 Created / 204 No Content | Bien / creado / bien, sin cuerpo |
| 301, 302, 307, 308 | Redirección (con el encabezado Location) |
| 400 Bad Request | Los datos que llegaron no son válidos |
| 401 Unauthorized / 403 Forbidden | Falta identificarse / no tiene permiso |
| 404 Not Found / 405 Method Not Allowed | No existe / ese método no se acepta ahí |
| 500 Internal Server Error | Algo falló en el servidor |
Servir archivos
import { createReadStream } from "node:fs";
import { stat } from "node:fs/promises";
import path from "node:path";
const PUBLICA = path.join(import.meta.dirname, "publico");
const TIPOS = { ".html": "text/html", ".css": "text/css", ".js": "text/javascript", ".png": "image/png" };
async function servirArchivo(pathname, res) {
const ruta = path.join(PUBLICA, pathname);
if (!ruta.startsWith(PUBLICA + path.sep)) return json(res, 403, { error: "prohibido" }); // nada de ../
try {
await stat(ruta);
res.writeHead(200, { "Content-Type": TIPOS[path.extname(ruta)] ?? "application/octet-stream" });
createReadStream(ruta).pipe(res); // el archivo viaja por partes
} catch {
json(res, 404, { error: "no existe" });
}
}
Para qué un framework
Lo que acabas de escribir a mano (rutas con parámetros, leer JSON, validar, manejar errores, archivos estáticos) es lo que resuelven los frameworks:
- Hono: pequeño, rápido y basado en
RequestyResponse: funciona igual en Node.js, Deno, Bun y Cloudflare Workers. - Fastify: muy rápido, con validación por esquemas y un sistema de plugins.
- Express: el más antiguo y conocido, con un ecosistema enorme de middlewares.
import { Hono } from "hono";
import { serve } from "@hono/node-server";
const app = new Hono();
app.get("/tareas/:id", (c) => c.json({ id: Number(c.req.param("id")) }));
serve({ fetch: app.fetch, port: 3000 });
Resumen
http.createServer((req, res) => …)se llama una vez por petición.- Mira
req.methody la ruta (new URL(req.url, …)) para decidir; responde conwriteHeadyend. - El cuerpo de una petición es un stream: léelo con
for await. - Una petición, una respuesta: termina cada rama con
return. - Los frameworks (Hono, Fastify, Express) resuelven rutas, cuerpos, validación y errores.
¡A practicar!
Tu progreso se guarda en este navegador.
Autoevaluación: Peticiones y respuestas
Resuelto
Elige una respuesta en cada pregunta.
¿Qué recibe la función de
http.createServer((req, res) => …)?¿Cómo se lee el cuerpo de una petición POST con
node:http?¿Qué código de estado corresponde a "creado"?
¿Por qué existen frameworks como Hono, Fastify o Express?
Ordena la salida: La vida de una petición
Resuelto
Un servidor que recibe un POST desde otra terminal. Ordena lo que aparecería en la terminal del servidor.
1import http from "node:http";2 3const servidor = http.createServer(async (req, res) => {4 console.log("llegó", req.method, req.url);5 let cuerpo = "";6 for await (const parte of req) cuerpo += parte;7 console.log("cuerpo:", cuerpo);8 res.writeHead(201, { "Content-Type": "application/json" });9 res.end(JSON.stringify({ creado: true }));10 console.log("respondido");11});12 13servidor.listen(3000, () => console.log("escuchando en 3000"));14 15// Desde otra terminal: curl -X POST -d "té" http://localhost:3000/pedidosConsola, de arriba abajo
- cuerpo: té
- escuchando en 3000
- respondido
- llegó POST /pedidos
El servidor avisa cuando empieza a escuchar. Cada petición llama a la función: primero se conocen el método y la URL, después se termina de recibir el cuerpo (un stream), y al final se escribe la respuesta.
Detective: Dos respuestas para una petición
Resuelto
El servidor se cae cada vez que alguien consulta /salud. Encuentra la línea y elige el arreglo.
Consola
node:_http_outgoing:699
throw new ERR_HTTP_HEADERS_SENT('set');
^
Error [ERR_HTTP_HEADERS_SENT]: Cannot write headers after they are sent to the client
at ServerResponse.writeHead (node:_http_server:345:11)
at Server.<anonymous> (file:///proyecto/servidor.mjs:8:7) {
code: 'ERR_HTTP_HEADERS_SENT'
}Paso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?