Home / Backend / Node.js desde cero: event loop, I/O sin bloqueo y cuándo elegirlo
Node.js desde cero: event loop, I/O sin bloqueo y cuándo elegirlo

Node.js desde cero: event loop, I/O sin bloqueo y cuándo elegirlo

19 November 2026 · 25 min de lectura ··

Qué es Node.js y por qué cambió el desarrollo de servidores

Durante años, JavaScript fue un lenguaje confinado al navegador. Servía para validar formularios, animar menús y poco más. Node.js rompió esa frontera al empaquetar el motor V8, el mismo que ejecuta JavaScript en Chrome, dentro de un programa que se puede lanzar desde la terminal y que tiene acceso al sistema de archivos, a la red y a los procesos del sistema operativo. Con ello, un lenguaje pensado para páginas web pasó a ser una opción seria para escribir servidores, herramientas de línea de comandos, scripts de automatización y servicios en la nube.

Conviene precisar qué es y qué no es. Node.js no es un lenguaje ni un framework. Es un entorno de ejecución: un binario que incluye el motor de JavaScript, una biblioteca estándar con módulos para trabajar con archivos, redes, criptografía, flujos de datos y hilos, y una capa de integración con el sistema operativo llamada libuv. Sobre ese entorno se construyen frameworks como Express, Fastify o NestJS, pero ninguno de ellos es imprescindible para escribir un servidor funcional.

Lo que distingue a Node.js de otras plataformas no es su velocidad bruta, sino su modelo de concurrencia. Mientras que los servidores tradicionales asignan un hilo a cada conexión, Node.js ejecuta tu código JavaScript en un único hilo y delega el trabajo de espera, como leer un disco o contestar una petición de red, al sistema operativo. Esa decisión de diseño tiene consecuencias enormes, tanto buenas como malas, y entenderla es la diferencia entre escribir servicios que aguantan miles de conexiones y escribir servicios que se congelan con tres usuarios.

En este artículo recorreremos el modelo mental completo: cómo funciona el event loop, qué significa que una operación sea bloqueante o no, cuándo conviene elegir esta plataforma, qué errores cometen casi todos los principiantes y cómo se compara con otras alternativas. Si todavía no tienes el entorno listo, antes de seguir puedes revisar la guía completa para instalar Node.js en Windows, macOS y Linux, y así podrás probar cada ejemplo mientras lees.

Versiones actuales y cómo elegir la correcta

Antes de escribir código conviene fijar qué versión usar, porque el comportamiento de algunas APIs cambia entre líneas. Node.js publica una versión mayor nueva cada año y las pares pasan a ser de soporte a largo plazo, conocido como LTS. A fecha de noviembre de 2026, la página oficial de lanzamientos lista la línea 26 (nombre en clave Lithium) como LTS, junto con la 24 (Krypton) y la 22 (Jod), que también siguen con soporte. La línea 27 aparece todavía en fase alfa, y las líneas impares anteriores, como la 25 o la 23, ya están fuera de soporte.

La regla práctica es sencilla: en producción usa siempre una versión LTS, y para proyectos nuevos elige la LTS más reciente. Las versiones impares y las alfas sirven para probar novedades, no para desplegar servicios que otras personas dependan de usar. Los ejemplos de este artículo funcionan en cualquier LTS vigente.

Para comprobar qué tienes instalado basta con preguntar al propio entorno.

node --version
npm --version

La salida mostrará la versión de Node.js y la de npm que se instaló junto a ella. No hace falta instalar npm por separado, porque viaja dentro del instalador oficial. Si trabajas en varios proyectos que exigen versiones distintas, lo más cómodo es usar un gestor de versiones; en la guía sobre cómo instalar y usar nvm para gestionar versiones de Node.js se explica el flujo completo para cambiar de versión por proyecto sin conflictos.

Algunas cosas que antes requerían paquetes externos ya vienen incluidas en las versiones modernas. La función fetch está disponible de forma global, hay un ejecutor de pruebas integrado en el módulo node:test, el modo de vigilancia se activa con --watch y los archivos de variables de entorno se cargan con --env-file. Esto reduce la cantidad de dependencias de un proyecto pequeño casi a cero, y es una de las razones por las que hoy un script de Node.js se puede escribir en un único archivo.

El modelo de un solo hilo explicado con una cafetería

La idea central se entiende mejor con una analogía. Imagina una cafetería con un solo camarero. En el modelo tradicional, cada cliente que entra recibe a su propio camarero personal, que se queda a su lado hasta que el café está listo. Si llegan cien clientes, necesitas cien camareros, y la mayoría pasan el tiempo mirando cómo se calienta la leche.

En el modelo de Node.js hay un único camarero, pero nunca espera. Toma el pedido del primer cliente, deja el café en la máquina y, sin quedarse mirando, atiende al siguiente. Cuando la máquina avisa de que un café está listo, el camarero lo recoge y lo entrega. El camarero es tu código JavaScript, la máquina de café es el sistema operativo y el aviso es un callback o una promesa que se resuelve.

Este esquema funciona de maravilla mientras el camarero solo hace tareas cortas: tomar pedidos, entregar tazas, cobrar. Si en cambio se pone a tostar granos a mano durante cinco minutos, todos los clientes esperan, incluidos los que solo querían un vaso de agua. Esa es la limitación fundamental: un único hilo es eficiente para coordinar esperas, pero desastroso para realizar cálculos largos.

Es importante aclarar un malentendido frecuente. Cuando se dice que Node.js es de un solo hilo, se refiere al hilo donde corre tu código JavaScript. El proceso completo usa varios hilos internos: V8 tiene los suyos para la recolección de basura, y libuv mantiene un grupo de hilos para tareas que el sistema operativo no ofrece de forma asíncrona. Tú no los ves ni los controlas directamente, pero existen y hacen parte del trabajo.

Cómo funciona el event loop paso a paso

El event loop es el mecanismo que mantiene vivo al proceso y decide qué código ejecutar a continuación. Se puede ver como un bucle infinito con varias fases, cada una con su propia cola de tareas pendientes. Mientras queden tareas o recursos abiertos, como un servidor escuchando, el bucle sigue girando; cuando no queda nada por hacer, el proceso termina por sí solo.

Las fases principales, simplificadas, son las siguientes. Primero se ejecutan los temporizadores vencidos creados con setTimeout y setInterval. Después se procesan los callbacks de operaciones de entrada y salida que ya terminaron. Luego viene la fase de sondeo, donde el bucle espera nuevos eventos de red o de disco si no tiene otra cosa que hacer. A continuación se ejecutan los callbacks programados con setImmediate, y por último se gestionan los cierres, como un socket que se cierra.

Entre una fase y la siguiente, e incluso después de cada callback, Node.js vacía dos colas especiales de mayor prioridad. La primera es la de process.nextTick, y la segunda es la de microtareas, donde caen las promesas resueltas y las funciones registradas con queueMicrotask. Esa prioridad explica un comportamiento que sorprende a muchos: una promesa ya resuelta se ejecuta antes que un temporizador de cero milisegundos.

Veámoslo con un experimento que puedes copiar tal cual.

console.log("1. inicio del script");

setTimeout(() => console.log("5. temporizador de 0 ms"), 0);

setImmediate(() => console.log("6. setImmediate"));

Promise.resolve().then(() => console.log("4. microtarea de promesa"));

process.nextTick(() => console.log("3. nextTick"));

console.log("2. fin del script síncrono");

La salida esperada muestra el orden real de ejecución.

1. inicio del script
2. fin del script síncrono
3. nextTick
4. microtarea de promesa
5. temporizador de 0 ms
6. setImmediate

Observa el patrón. Primero termina todo el código síncrono del archivo. Luego se vacía la cola de nextTick, después las microtareas, y solo entonces el bucle pasa a las fases con temporizadores y callbacks. Un detalle sutil: el orden entre setTimeout(..., 0) y setImmediate puede variar cuando se programan desde el script principal, porque depende del rendimiento del proceso en ese instante. Dentro de un callback de entrada y salida, en cambio, setImmediate siempre llega primero. No conviene apoyar la lógica de una aplicación en esa diferencia.

Código bloqueante frente a código no bloqueante

Una operación es bloqueante cuando el hilo principal queda detenido hasta que termina. Es no bloqueante cuando se inicia, se devuelve el control de inmediato y el resultado llega después a través de un callback, una promesa o un evento. En la biblioteca estándar, la convención es clara: los métodos cuyo nombre acaba en Sync bloquean, y los demás no.

Comparemos dos formas de leer un archivo de configuración.

import { readFileSync } from "node:fs";
import { readFile } from "node:fs/promises";

// Versión bloqueante: nada más se ejecuta hasta terminar
const textoSync = readFileSync("./ajustes.json", "utf8");
console.log("Leído de forma síncrona:", textoSync.length, "caracteres");

// Versión no bloqueante: el hilo queda libre mientras el disco responde
const textoAsync = await readFile("./ajustes.json", "utf8");
console.log("Leído de forma asíncrona:", textoAsync.length, "caracteres");

En un script de arranque que se ejecuta una vez, la versión síncrona es perfectamente aceptable e incluso más simple. El problema aparece dentro de un servidor que atiende peticiones. Si cada petición hace una lectura síncrona de un archivo grande, todas las demás peticiones esperan en fila mientras el disco trabaja. Con un archivo pequeño y en caché apenas se nota, pero con uno grande o con un disco lento, la latencia de todo el servicio se dispara.

La diferencia se aprecia bien midiendo. En el siguiente servidor, una ruta bloquea el hilo con un bucle largo y otra responde de inmediato.

import { createServer } from "node:http";

const servidor = createServer((peticion, respuesta) => {
  if (peticion.url === "/lento") {
    const limite = Date.now() + 5000;
    while (Date.now() < limite) {
      // espera activa: el hilo no puede atender a nadie más
    }
    respuesta.end("terminé tras 5 segundos\n");
    return;
  }
  respuesta.end("respuesta inmediata\n");
});

servidor.listen(3000, () => console.log("Escuchando en el puerto 3000"));

Si abres la ruta lenta en una pestaña y, mientras tanto, pides la ruta rápida en otra, comprobarás que la segunda también se queda esperando casi cinco segundos. No hay ningún error en el código, simplemente el único hilo está ocupado. Esta es la demostración más clara de por qué bloquear el bucle de eventos es el pecado capital de la plataforma.

Una forma útil de pensarlo es que existen dos tipos de espera. La espera de entrada y salida, como una consulta a una base de datos o una llamada a otra API, no consume procesador: es tiempo muerto que Node.js aprovecha para atender otras cosas. La espera de cálculo, como comprimir una imagen o calcular un hash gigante, sí consume procesador y no se puede solapar en un único hilo. Node.js destaca en la primera y sufre en la segunda.

Evolución de la asincronía: callbacks, promesas y async/await

La forma de expresar operaciones no bloqueantes ha cambiado mucho. Al principio todo eran callbacks con la convención de recibir primero el error y después el resultado. Funcionaban, pero encadenar varias operaciones producía pirámides de funciones anidadas difíciles de leer y de depurar.

import { readFile, writeFile } from "node:fs";

readFile("./entrada.txt", "utf8", (error, contenido) => {
  if (error) {
    console.error("No se pudo leer:", error.message);
    return;
  }
  writeFile("./salida.txt", contenido.toUpperCase(), (errorEscritura) => {
    if (errorEscritura) {
      console.error("No se pudo escribir:", errorEscritura.message);
      return;
    }
    console.log("Copia en mayúsculas creada");
  });
});

Las promesas aplanaron esa estructura y permitieron manejar errores en un único lugar. Hoy los módulos principales de la biblioteca estándar ofrecen una variante basada en promesas, accesible desde rutas como node:fs/promises o node:timers/promises. Y por encima de las promesas llegó async/await, que permite escribir código asíncrono con aspecto secuencial.

import { readFile, writeFile } from "node:fs/promises";

async function copiarEnMayusculas(origen, destino) {
  try {
    const contenido = await readFile(origen, "utf8");
    await writeFile(destino, contenido.toUpperCase());
    console.log("Copia en mayúsculas creada");
  } catch (error) {
    console.error("Falló la operación:", error.message);
  }
}

await copiarEnMayusculas("./entrada.txt", "./salida.txt");

El await de nivel superior, usado en la última línea, funciona en módulos ES, que son el formato por defecto cuando el archivo usa la extensión .mjs o el proyecto declara el tipo module en su configuración. Una confusión muy extendida es creer que await bloquea el hilo. No lo hace: suspende solo esa función y devuelve el control al bucle de eventos, que sigue atendiendo otras tareas hasta que la promesa se resuelve.

Si todavía te topas con librerías antiguas basadas en callbacks, puedes convertirlas con util.promisify, que envuelve una función con la convención clásica y devuelve otra que entrega una promesa. Es la vía recomendada antes que reescribir la librería o mezclar estilos dentro del mismo flujo.

Ejecutar tareas en paralelo sin perder el control

Una ventaja directa del modelo asíncrono es la facilidad para lanzar varias operaciones de entrada y salida a la vez. Si necesitas consultar tres servicios independientes, esperarlos uno tras otro suma sus tiempos, mientras que lanzarlos juntos hace que el tiempo total sea el del más lento.

async function cargarPanel(idUsuario) {
  const inicio = performance.now();

  const [perfil, pedidos, avisos] = await Promise.all([
    fetch(`https://api.ejemplo.test/usuarios/${idUsuario}`).then((r) => r.json()),
    fetch(`https://api.ejemplo.test/usuarios/${idUsuario}/pedidos`).then((r) => r.json()),
    fetch(`https://api.ejemplo.test/usuarios/${idUsuario}/avisos`).then((r) => r.json()),
  ]);

  const duracion = Math.round(performance.now() - inicio);
  console.log(`Panel listo en ${duracion} ms`);
  return { perfil, pedidos, avisos };
}

Promise.all falla en cuanto una de las promesas se rechaza. Cuando quieres conocer el resultado de todas aunque alguna falle, usa Promise.allSettled, que devuelve el estado de cada una. Y cuando solo importa la primera que responda, por ejemplo para consultar réplicas de un mismo servicio, Promise.race o Promise.any encajan mejor.

Hay un límite que conviene respetar: lanzar diez mil peticiones simultáneas no es una buena idea. Saturarías la red, el servicio remoto o la memoria. Lo razonable es procesar por lotes con un tope de concurrencia, que puedes implementar con una pequeña cola o con una librería dedicada. Otra buena práctica es acotar el tiempo de espera con AbortSignal.timeout, para que una llamada colgada no deje tu servicio esperando indefinidamente.

const respuesta = await fetch("https://api.ejemplo.test/estado", {
  signal: AbortSignal.timeout(3000),
});
console.log(respuesta.status);

El grupo de hilos de libuv y las operaciones que lo usan

Aunque tu JavaScript use un hilo, algunas operaciones se resuelven en un grupo de hilos interno, que por defecto tiene cuatro. Ahí terminan las tareas para las que el sistema operativo no ofrece una interfaz asíncrona fiable: muchas operaciones del sistema de archivos, la resolución de nombres con dns.lookup, y las funciones de criptografía y compresión que consumen procesador, como crypto.pbkdf2 o zlib.

Las operaciones de red, en cambio, no pasan por ese grupo. Los sockets usan mecanismos nativos del sistema operativo, como epoll en Linux, kqueue en macOS e IOCP en Windows, que permiten vigilar miles de conexiones desde un solo hilo. Por eso Node.js maneja tantas conexiones simultáneas con tan pocos recursos.

Entender el grupo explica fenómenos que de otro modo parecen misteriosos. Si lanzas ocho derivaciones de claves a la vez, las cuatro primeras se ejecutan en paralelo y las otras cuatro esperan turno, de modo que el tiempo total se parece más a dos rondas que a una. Puedes ampliar el grupo con la variable de entorno UV_THREADPOOL_SIZE, aunque subirla sin criterio no resuelve cuellos de botella de procesador y solo tiene sentido si realmente hay hilos sobrantes en la máquina.

import { pbkdf2 } from "node:crypto";

const inicio = Date.now();

for (let i = 1; i <= 8; i++) {
  pbkdf2("clave-secreta", "sal", 600000, 64, "sha512", () => {
    console.log(`Tarea ${i} terminada a los ${Date.now() - inicio} ms`);
  });
}

Al ejecutarlo en una máquina con al menos cuatro núcleos verás dos oleadas de resultados con tiempos parecidos dentro de cada oleada. Ese escalonamiento es la firma del grupo de hilos en acción.

Cuándo Node.js es la mejor opción

Con el modelo claro, la pregunta práctica es dónde encaja. Node.js brilla en cargas dominadas por la espera de entrada y salida, donde el servidor pasa casi todo el tiempo aguardando respuestas de otras piezas: una base de datos, una caché, un servicio de pagos, un navegador conectado.

Los casos de uso más habituales son estos:

  • APIs REST y GraphQL que orquestan consultas a bases de datos y servicios externos.
  • Aplicaciones en tiempo real como chats, paneles en vivo, notificaciones y herramientas colaborativas, gracias a WebSockets y eventos enviados por el servidor.
  • Pasarelas y capas intermedias que agregan datos de varios servicios para un cliente móvil o web.
  • Transmisión de contenido y procesamiento de flujos, donde los datos se procesan por trozos sin cargarlos enteros en memoria.
  • Herramientas de línea de comandos, generadores de sitios y sistemas de compilación, que son el motor oculto de gran parte del ecosistema frontend.
  • Funciones sin servidor, donde el arranque rápido y el bajo consumo de memoria son una ventaja.

Un ejemplo concreto ayuda. Imagina un servicio de seguimiento de envíos que muestra la posición de los paquetes en un mapa. Miles de clientes mantienen una conexión abierta y cada pocos segundos reciben una actualización. Casi todo el trabajo consiste en mantener conexiones y reenviar mensajes breves, es decir, entrada y salida pura. Un solo proceso de Node.js puede sostener decenas de miles de conexiones de este tipo con una huella de memoria modesta.

Otra ventaja que pesa en la decisión es usar el mismo lenguaje en cliente y servidor. Un equipo pequeño puede compartir validaciones, tipos y utilidades entre el frontend y el backend, y una misma persona puede moverse entre ambos lados sin cambiar de herramientas. Además, el gestor de paquetes npm aloja uno de los repositorios de librerías más grandes que existen, lo que acelera el desarrollo, aunque también exige criterio al elegir dependencias.

Si tu caso implica mover grandes volúmenes de datos, conviene conocer a fondo los flujos, porque permiten procesar un archivo de varios gigabytes con una memoria casi constante. Todo lo relativo a ellos está desarrollado en el artículo sobre Node.js streams en un solo lugar, un complemento natural de lo que hemos visto hasta aquí.

Cuándo no usarlo o cuándo hay que tomar precauciones

La contrapartida del modelo es que las tareas intensivas de procesador son su punto débil. Calcular la transformada de una imagen enorme, entrenar un modelo, renderizar vídeo o ejecutar simulaciones numéricas pesadas ocupa el hilo principal y congela todo lo demás. En esos escenarios, un lenguaje con hilos reales y buen rendimiento numérico suele ser una elección más natural.

Eso no significa que sea imposible hacerlo en Node.js. Existen vías para sacar el trabajo pesado del hilo principal. La más directa son los hilos de trabajo, que se crean con el módulo node:worker_threads y tienen su propio motor de JavaScript y su propio bucle de eventos. Se comunican con el hilo principal mediante mensajes, y pueden compartir memoria de forma explícita cuando hace falta.

// principal.mjs
import { Worker } from "node:worker_threads";

function sumarEnHilo(limite) {
  return new Promise((resolver, rechazar) => {
    const hilo = new Worker(new URL("./sumador.mjs", import.meta.url), {
      workerData: { limite },
    });
    hilo.once("message", resolver);
    hilo.once("error", rechazar);
  });
}

console.log("Lanzando cálculo pesado...");
const total = await sumarEnHilo(2_000_000_000);
console.log("Resultado:", total);
// sumador.mjs
import { parentPort, workerData } from "node:worker_threads";

let acumulado = 0;
for (let i = 1; i <= workerData.limite; i++) {
  acumulado += i;
}
parentPort.postMessage(acumulado);

Mientras el hilo de trabajo calcula, el hilo principal sigue libre para atender peticiones. Esa separación convierte un cálculo bloqueante en una operación que, vista desde fuera, se comporta como cualquier otra tarea asíncrona. Si el trabajo pesado es frecuente, crea un conjunto reutilizable de hilos en lugar de abrir uno nuevo por cada petición, porque arrancar un hilo tiene su coste.

Otra alternativa es el módulo node:cluster o, a nivel de despliegue, ejecutar varias instancias del proceso detrás de un balanceador. Eso aprovecha todos los núcleos de la máquina para atender más peticiones en paralelo, aunque no acelera una tarea individual. Y si la parte pesada es crítica, la opción más limpia suele ser aislarla en un servicio aparte escrito en otro lenguaje, que Node.js consulta como cualquier otro servicio externo.

Errores comunes que conviene evitar

Los problemas más frecuentes en proyectos de Node.js nacen casi siempre de no respetar el modelo de un solo hilo o de manejar mal la asincronía. Estos son los que más se repiten.

El primero es usar funciones síncronas dentro del código que atiende peticiones. Un readFileSync, un execSync o un pbkdf2Sync en un manejador de ruta parecen inofensivos en desarrollo, donde hay un único usuario, y se vuelven un desastre en producción. La regla es reservar las variantes síncronas para el arranque del proceso o para scripts puntuales.

El segundo es olvidar el await. Llamar a una función asíncrona sin esperarla devuelve una promesa pendiente, y el código siguiente se ejecuta antes de que el trabajo termine. Peor aún, si esa promesa se rechaza y nadie la captura, el proceso puede terminar con un error de rechazo no manejado. Un ejemplo típico:

async function guardarRegistro(datos) {
  await baseDeDatos.insertar(datos);
}

// Error: no se espera el resultado, y cualquier fallo se pierde
guardarRegistro({ nombre: "Lucía" });
console.log("Registro guardado"); // se imprime aunque todavía no se guardó

// Correcto
await guardarRegistro({ nombre: "Lucía" });
console.log("Registro guardado");

El tercero es usar forEach con funciones asíncronas esperando que se aguarde a cada iteración. El método ignora las promesas que devuelven los callbacks, así que el código posterior continúa sin esperar. Para procesar elementos de manera secuencial usa un bucle for...of con await, y para hacerlo en paralelo combina map con Promise.all.

const identificadores = [101, 102, 103];

// Secuencial: uno tras otro
for (const id of identificadores) {
  await procesarPedido(id);
}

// En paralelo: todos a la vez
await Promise.all(identificadores.map((id) => procesarPedido(id)));

El cuarto error es no gestionar los fallos en los manejadores de eventos. Un emisor de eventos que lanza un evento error sin que nadie lo escuche termina el proceso. Registra siempre un escuchador para ese evento en flujos, sockets y emisores propios. Del mismo modo, conviene tener un manejador global para unhandledRejection que al menos registre el problema en los logs, aunque no sustituye a un tratamiento correcto en cada punto.

El quinto es acumular estado en memoria sin control. Como el proceso vive mucho tiempo, una caché sin límite, una lista de oyentes que nunca se elimina o una colección global que crece con cada petición provoca fugas de memoria. Pon límites de tamaño y caducidad a las cachés y elimina los oyentes cuando dejan de ser necesarios.

El sexto es confiar en datos de entrada sin validarlos. Un objeto JSON recibido de un cliente puede contener cualquier cosa, incluidos campos inesperados o tipos incorrectos. Valida la forma de los datos en el borde de la aplicación, con una librería de esquemas, antes de que lleguen a la lógica de negocio. Y no ejecutes nunca cadenas recibidas con eval ni las pases sin sanear a un comando de sistema.

Cómo detectar que el bucle de eventos está saturado

Cuando un servicio de Node.js va lento sin que el procesador de la máquina esté al límite, la sospecha habitual es un bucle de eventos bloqueado. Existen formas directas de medirlo. El módulo node:perf_hooks ofrece un monitor de retraso del bucle, que mide cuánto se aleja la ejecución de los temporizadores respecto al momento en que debían correr.

import { monitorEventLoopDelay } from "node:perf_hooks";

const monitor = monitorEventLoopDelay({ resolution: 20 });
monitor.enable();

setInterval(() => {
  const p99 = Math.round(monitor.percentile(99) / 1e6);
  const media = Math.round(monitor.mean / 1e6);
  console.log(`Retraso del bucle: media ${media} ms, p99 ${p99} ms`);
  monitor.reset();
}, 5000);

Un retraso medio de pocos milisegundos es normal. Si el percentil 99 sube a cientos de milisegundos, algo está acaparando el hilo. Para localizar el culpable, ejecuta el proceso con el perfilador integrado, que genera un informe de dónde se gasta el tiempo.

node --cpu-prof servidor.mjs

Esto crea un archivo de perfil que puedes abrir en las herramientas de desarrollo de un navegador basado en Chromium. Allí verás qué funciones ocupan más tiempo y si hay bucles largos, serializaciones de JSON enormes o expresiones regulares con retroceso excesivo, uno de los bloqueos más traicioneros porque una entrada maliciosa puede paralizar el servidor.

Además de medir, existen hábitos preventivos. Divide los trabajos largos en trozos pequeños y cede el control entre ellos con setImmediate, de forma que otras tareas se intercalen. Evita analizar o generar JSON de varios megabytes en el hilo principal. Y limita el tamaño de los cuerpos de petición que aceptas, porque un atacante puede enviar cargas gigantes solo para consumir tiempo de procesador.

async function procesarEnTrozos(lista, tamanoTrozo = 500) {
  for (let i = 0; i < lista.length; i += tamanoTrozo) {
    const trozo = lista.slice(i, i + tamanoTrozo);
    trozo.forEach(transformar);
    // cede el turno al bucle antes del siguiente trozo
    await new Promise((resolver) => setImmediate(resolver));
  }
}

Comparativa con otras plataformas de servidor

Elegir tecnología no es una cuestión de buena o mala, sino de ajuste. Comparar los modelos de concurrencia ayuda a decidir con criterio.

Frente a los servidores clásicos con un hilo por petición, como los de Java con contenedores tradicionales o PHP con procesos por solicitud, Node.js consume mucha menos memoria por conexión y maneja mejor miles de conexiones ociosas. A cambio, un fallo de bloqueo afecta a todos los usuarios a la vez, mientras que en el modelo de hilos solo se ven afectados los usuarios cuyas peticiones están en el hilo problemático.

Frente a Python con sus marcos asíncronos, el rendimiento en entrada y salida es comparable en concepto, ya que ambos usan un bucle de eventos. La ventaja de Python está en su ecosistema de ciencia de datos y aprendizaje automático, mientras que la de Node.js está en la madurez de su motor, que compila el código a instrucciones nativas mientras se ejecuta, y en compartir lenguaje con el navegador.

Frente a Go, que ofrece corrutinas ligeras repartidas entre todos los núcleos, Go aprovecha el paralelismo real sin esfuerzo y tiene un rendimiento más predecible en cargas de procesador. Node.js responde con una curva de aprendizaje más suave para quien ya sabe JavaScript y con un ecosistema enorme de librerías, pero exige más disciplina para no bloquear el hilo principal.

Frente a Rust, la diferencia es de objetivo. Rust ofrece control fino y rendimiento máximo con garantías de seguridad en memoria, a costa de una curva de aprendizaje pronunciada. Node.js prioriza la velocidad de desarrollo. En la práctica, muchos equipos combinan ambos: Node.js para la capa de API y módulos nativos o servicios en Rust para los fragmentos que exigen máximo rendimiento.

Existen además otros entornos de ejecución de JavaScript, como Deno y Bun, que ofrecen variantes de la misma idea con otras decisiones sobre seguridad, herramientas integradas y compatibilidad. Node.js conserva la ventaja de la base instalada, la estabilidad de sus versiones LTS y la compatibilidad con casi cualquier paquete publicado, algo decisivo cuando el proyecto debe mantenerse durante años.

Buenas prácticas para empezar con buen pie

Algunas decisiones tempranas evitan dolores de cabeza más adelante. Estas son las que más se notan en la práctica.

  • Fija la versión de Node.js del proyecto en un archivo de configuración o en el campo de motores del manifiesto, para que todo el equipo y el servidor de despliegue usen la misma.
  • Usa módulos ES con importaciones explícitas del prefijo node: para los módulos internos, lo que deja claro que no son paquetes de terceros.
  • Mantén las dependencias al mínimo y revisa las vulnerabilidades conocidas con la auditoría de npm de forma periódica.
  • Guarda los secretos en variables de entorno y no en el repositorio; el cargador de archivos de entorno integrado simplifica el desarrollo local.
  • Maneja las señales de apagado para cerrar conexiones y terminar las peticiones en curso antes de que el proceso salga.
  • Escribe pruebas con el ejecutor integrado y automatiza su ejecución en cada cambio.
  • Registra mensajes estructurados con niveles y contexto, no cadenas sueltas, para poder buscar y agregar en producción.

Como ejemplo de arranque mínimo y ordenado, este servidor usa módulos ES, cierre limpio y ningún paquete externo.

import { createServer } from "node:http";

const puerto = Number(process.env.PORT ?? 3000);

const servidor = createServer((peticion, respuesta) => {
  respuesta.setHeader("Content-Type", "application/json; charset=utf-8");
  respuesta.end(JSON.stringify({ estado: "operativo", hora: new Date().toISOString() }));
});

servidor.listen(puerto, () => {
  console.log(`Servicio listo en el puerto ${puerto}`);
});

function apagar(senal) {
  console.log(`Recibida ${senal}, cerrando...`);
  servidor.close(() => process.exit(0));
}

process.on("SIGTERM", () => apagar("SIGTERM"));
process.on("SIGINT", () => apagar("SIGINT"));

Para ejecutarlo con recarga automática durante el desarrollo basta una opción del propio entorno.

node --watch --env-file=.env servidor.mjs

Una estructura sencilla para un proyecto pequeño podría verse así, sin demasiadas carpetas hasta que el tamaño lo justifique.

servicio-envios/
├── package.json
├── .env
├── src/
│   ├── servidor.mjs
│   ├── rutas/
│   │   └── paquetes.mjs
│   └── utilidades/
│       └── validar.mjs
└── test/
    └── paquetes.test.mjs

Y una prueba mínima con el ejecutor integrado, sin instalar nada adicional.

import { test } from "node:test";
import assert from "node:assert/strict";
import { esCodigoValido } from "../src/utilidades/validar.mjs";

test("acepta códigos de seguimiento con el formato esperado", () => {
  assert.equal(esCodigoValido("ENV-12345"), true);
});

test("rechaza códigos vacíos", () => {
  assert.equal(esCodigoValido(""), false);
});

Un caso práctico: agregador de precios no bloqueante

Para consolidar lo aprendido, imaginemos un servicio que consulta los precios de un producto en tres tiendas y devuelve el más barato. Cada consulta tarda entre medio segundo y dos segundos, por lo que el diseño decide si el cliente espera uno o hasta seis segundos.

const tiendas = [
  "https://tienda-a.ejemplo.test/api/precio",
  "https://tienda-b.ejemplo.test/api/precio",
  "https://tienda-c.ejemplo.test/api/precio",
];

async function consultar(url, codigo) {
  const respuesta = await fetch(`${url}?codigo=${encodeURIComponent(codigo)}`, {
    signal: AbortSignal.timeout(2500),
  });
  if (!respuesta.ok) {
    throw new Error(`Fallo ${respuesta.status} en ${url}`);
  }
  const { precio } = await respuesta.json();
  return { url, precio };
}

export async function mejorPrecio(codigo) {
  const resultados = await Promise.allSettled(tiendas.map((t) => consultar(t, codigo)));

  const validos = resultados
    .filter((r) => r.status === "fulfilled")
    .map((r) => r.value);

  if (validos.length === 0) {
    throw new Error("Ninguna tienda respondió a tiempo");
  }
  return validos.reduce((mejor, actual) => (actual.precio < mejor.precio ? actual : mejor));
}

El diseño tiene varias decisiones deliberadas. Las tres consultas salen a la vez, así que el tiempo total es el de la tienda más lenta y no la suma de todas. Cada petición tiene un límite de tiempo, de modo que una tienda caída no arrastra al resto. Se usa allSettled para que el fallo de una fuente no anule los resultados de las demás, y solo se lanza un error si no responde ninguna. Todo ello sin crear un solo hilo adicional ni bloquear el bucle, porque el trabajo es esperar, que es justo lo que Node.js hace mejor.

Si más adelante cada tienda devolviera un catálogo enorme que hubiera que filtrar y ordenar con cálculos complejos, ese procesamiento sí empezaría a competir por el hilo principal. Ahí sería el momento de medir el retraso del bucle y valorar trasladar el filtrado a un hilo de trabajo.

Conclusiones

Node.js ofrece un modelo de ejecución sencillo de enunciar y sutil de dominar: un único hilo para tu código, un bucle de eventos que reparte el turno y un sistema operativo que se encarga de las esperas. De esa combinación sale su gran virtud, que es atender muchísimas conexiones con pocos recursos, y su gran peligro, que es que cualquier operación larga detiene a todos los usuarios a la vez.

La regla de oro es no bloquear el bucle. Usa las variantes asíncronas en el código que atiende peticiones, lanza en paralelo lo que sea independiente, limita los tiempos de espera y saca los cálculos pesados a hilos de trabajo o a servicios especializados. Mide el retraso del bucle en producción en lugar de adivinar, y ten presentes los errores típicos: olvidar await, usar forEach con funciones asíncronas, dejar eventos de error sin escuchar y dejar crecer la memoria sin control.

En cuanto a la elección de plataforma, Node.js encaja de forma excelente en APIs, aplicaciones en tiempo real, herramientas de desarrollo y capas de integración, y compite con otras opciones cuando el trabajo es mayormente de entrada y salida. Para cargas de procesador intensas conviene complementarlo o elegir otra herramienta. Con la línea LTS vigente, las utilidades que ya vienen integradas y las buenas prácticas descritas, tienes una base sólida para construir servicios fiables y mantenibles.