¿Qué es el event loop en Node.js y cómo funciona?

Question

Accepted Answer

El **event loop** es el mecanismo que permite que Node.js, siendo de un solo hilo, realice **I/O no bloqueante**. Procesa continuamente una cola de callbacks: mientras tu JavaScript se ejecuta en un hilo, las operaciones de I/O se delegan y sus callbacks se ejecutan en el loop cuando se completan.

## Las fases del loop

Cada iteración ("tick") avanza por fases ordenadas, cada una con su propia cola de callbacks:

```text
   ┌───────────────────────────┐
┌─>│   timers (setTimeout)     │  ← callbacks de timers vencidos
│  ├───────────────────────────┤
│  │   pending I/O callbacks   │
│  ├───────────────────────────┤
│  │   poll (I/O events)       │  ← recupera nuevo I/O; ejecuta sus callbacks
│  ├───────────────────────────┤
│  │   check (setImmediate)    │
│  ├───────────────────────────┤
└──│   close callbacks         │
   └───────────────────────────┘
```

## Las microtasks se ejecutan entre fases (alta prioridad)

```js
console.log("1");                          // sync
setTimeout(() => console.log("2"), 0);     // fase timers (macrotask)
setImmediate(() => console.log("3"));      // fase check
Promise.resolve().then(() => console.log("4")); // microtask
process.nextTick(() => console.log("5"));  // nextTick — máxima prioridad
console.log("6");
// Salida: 1, 6, 5, 4, 2/3 (el orden timer vs immediate puede variar)
```

Después de cada fase (y tras el código síncrono), Node vacía las **microtasks**: primero los callbacks de `process.nextTick`, luego los callbacks de Promise — *antes* de continuar. Por eso una Promise resuelta se ejecuta antes que un `setTimeout(…, 0)`.

## Por qué permite concurrencia sin hilos

```text
Una consulta a la BD o una lectura de archivo se delega al SO/thread pool → Node sigue
ejecutando otro código → cuando el resultado está listo, su callback se encola → el loop lo ejecuta.
Un solo hilo, miles de operaciones en curso.
```

## La regla de oro: no bloquees el loop

```js
// ❌ un loop síncrono largo congela TODO — ningún otro callback puede ejecutarse
while (Date.now() - start < 5000) {}
```

Bloquear el único hilo detiene todo el procesamiento de solicitudes. Delega el trabajo intensivo de CPU a worker threads.

## Por qué es importante

El event loop es el corazón del modelo de rendimiento de Node — entender sus fases y la prioridad de las microtasks explica el orden de ejecución asíncrona, por qué Node maneja una concurrencia enorme en un solo hilo y la regla crítica de nunca bloquearlo.

Es fundamental para escribir código Node correcto y eficiente, y para depurar un orden de ejecución asíncrono sorprendente.