Saltar al contenido
JavaScript en el servidor

Un servidor HTTP desde cero

Lección 4 de 713 min3 ejercicios

Detrás de cada página y de cada API hay un servidor que recibe peticiones y devuelve respuestas. Con Node.js se puede escribir uno en pocas líneas, sin instalar nada. Hacerlo una vez desde cero, con node:http, es la mejor forma de entender qué hacen por ti los frameworks.

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 Request y Response: 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.method y la ruta (new URL(req.url, …)) para decidir; responde con writeHead y end.
  • 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

Elige una respuesta en cada pregunta.

  1. ¿Qué recibe la función de http.createServer((req, res) => …)?

  2. ¿Cómo se lee el cuerpo de una petición POST con node:http?

  3. ¿Qué código de estado corresponde a "creado"?

  4. ¿Por qué existen frameworks como Hono, Fastify o Express?

Ordena la salida: La vida de una petición

Un servidor que recibe un POST desde otra terminal. Ordena lo que aparecería en la terminal del servidor.

import http from "node:http"; const servidor = http.createServer(async (req, res) => {  console.log("llegó", req.method, req.url);  let cuerpo = "";  for await (const parte of req) cuerpo += parte;  console.log("cuerpo:", cuerpo);  res.writeHead(201, { "Content-Type": "application/json" });  res.end(JSON.stringify({ creado: true }));  console.log("respondido");}); servidor.listen(3000, () => console.log("escuchando en 3000")); // Desde otra terminal: curl -X POST -d "té" http://localhost:3000/pedidos

Consola, de arriba abajo

  1. cuerpo: té
  2. escuchando en 3000
  3. respondido
  4. llegó POST /pedidos

Detective: Dos respuestas para una petición

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.

domina-js · JavaScript en español, gratis y paso a paso.