Wat is de event loop in Node.js en hoe werkt het?

Question

Accepted Answer

De **event loop** is het mechanisme dat single-threaded Node.js **non-blocking I/O** laat uitvoeren. Het verwerkt voortdurend een wachtrij van callbacks: terwijl uw JavaScript op één thread wordt uitgevoerd, worden I/O-bewerkingen uitgesteld, en hun callbacks worden door de lus uitgevoerd wanneer deze voltooid zijn.

## De fasen van de loop

Elke iteratie ("tick") gaat door geordende fasen, elk met zijn eigen callback-wachtrij:

```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         │
   └───────────────────────────┘
```

## Microtasks worden tussen fasen uitgevoerd (hoge prioriteit)

```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)
```

Na elke fase (en na sync-code) verwerkt Node **microtasks**: eerst `process.nextTick` callbacks, daarna Promise callbacks — *voordat* het verdergaat. Dit is waarom een opgeloste Promise voor `setTimeout(…, 0)` wordt uitgevoerd.

## Waarom het concurrency zonder threads mogelijk maakt

```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.
```

## De basisregel: blokkeer de loop niet

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

De enkele thread blokkeren stopt alle request-afhandeling. Verplaats CPU-zwaar werk naar worker threads.

## Waarom het belangrijk is

De event loop is het hart van Node's prestatiemodel — inzicht in de fasen en de microtask-prioriteit verklaart asynchrone volgorde, waarom Node enorme gelijktijdigheid op één thread verwerkt, en de kritieke regel om het nooit te blokkeren.

Het is fundamenteel voor het schrijven van correcte, performante Node-code en voor het debuggen van verrassende asynchrone executievolgorde.