Qu'est-ce que la boucle d'événements en Node.js et comment fonctionne-t-elle ?

Question

Accepted Answer

La **boucle d'événements** est le mécanisme qui permet à Node.js, en tant que langage **single-threaded**, d'effectuer des **I/O non-bloquants**. Elle traite continuellement une file d'attente de callbacks : tandis que votre JavaScript s'exécute sur un thread unique, les opérations I/O sont déléguées, et leurs callbacks sont exécutés par la boucle une fois qu'elles se terminent.

## Les phases de la boucle

Chaque itération (« tick ») parcourt des phases ordonnées, chacune avec sa propre file de callbacks :

```text
   ┌───────────────────────────┐
┌─>│   timers (setTimeout)     │  ← expired timer callbacks
│  ├───────────────────────────┤
│  │   pending I/O callbacks   │
│  ├───────────────────────────┤
│  │   poll (I/O events)       │  ← retrieve new I/O; execute their callbacks
│  ├───────────────────────────┤
│  │   check (setImmediate)    │
│  ├───────────────────────────┤
└──│   close callbacks         │
   └───────────────────────────┘
```

## Les microtasks s'exécutent entre les phases (priorité élevée)

```js
console.log("1");                          // sync
setTimeout(() => console.log("2"), 0);     // timers phase (macrotask)
setImmediate(() => console.log("3"));      // check phase
Promise.resolve().then(() => console.log("4")); // microtask
process.nextTick(() => console.log("5"));  // nextTick — highest priority
console.log("6");
// Output: 1, 6, 5, 4, 2/3 (timer vs immediate order can vary)
```

Après chaque phase (et après le code synchrone), Node vide les **microtasks** : d'abord les callbacks `process.nextTick`, puis les callbacks Promise — *avant* de passer à la suite. C'est pourquoi une Promise résolue s'exécute avant un `setTimeout(…, 0)`.

## Pourquoi cela permet la concurrence sans threads

```text
A DB query or file read is handed to the OS/thread pool → Node keeps running
other code → when the result is ready, its callback is queued → the loop runs it.
One thread, thousands of in-flight operations.
```

## La règle cardinale : ne pas bloquer la boucle

```js
// ❌ a long synchronous loop freezes EVERYTHING — no other callback can run
while (Date.now() - start < 5000) {}
```

Bloquer le thread unique arrête tout traitement des requêtes. Déléguez le travail gourmand en CPU aux worker threads.

## Pourquoi c'est important

La boucle d'événements est le cœur du modèle de performance de Node — comprendre ses phases et la priorité des microtasks explique l'ordre d'exécution asynchrone, pourquoi Node gère une énorme concurrence sur un seul thread, et la règle critique de ne jamais la bloquer.

C'est fondamental pour écrire du code Node correct et performant, et pour déboguer un ordre d'exécution asynchrone surprenant.