X'inhu l-event loop fil-Node.js u kif jaħdem?

Question

Accepted Answer

L-**event loop** huwa l-mekkaniżmu li jippermettu Node.js li ddum fuq thread wieħed li jwettaq **non-blocking I/O**. Hu kontinwament jipproċessa queue ta' callbacks: filwaqt li JavaScript tiegħek iddum fuq thread wieħed, operazzjonijiet I/O jiġu trasferiti, u callbacks tagħhom jiġu esegwiti mill-loop meta jispiċċaw.

## Il-fażi tal-loop

Kull iterazzjoni ("tick") timxi mill-fażi ordnati, kull waħda bis-sieħba tal-queue tagħha stess ta' 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         │
   └───────────────────────────┘
```

## Microtasks iġu esegwiti bejn il-fażi (priorità għolja)

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

Wara kull fażi (u wara code sync), Node tixraq **microtasks**: callbacks `process.nextTick` l-ewwel, imbagħad callbacks Promise — *qabel* tmur 'l quddiem. Dan huwa għaliex Promise risoluta tiddum qabel `setTimeout(…, 0)`.

## Kif jippermettu concurrency mingħajr 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.
```

## Ir-regola kardinali: tħallix il-loop

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

Blokkar thread wieħed aqaf il-ħandle ta' requests kollha. Trasferixxi x-xogħol CPU-heavy għal worker threads.

## Għaliex dan huwa importanti

l-event loop huwa l-qalb tal-mudell ta' performance ta' Node — il-fehim tal-fażi tiegħu u l-priorità microtask jispjegaw l-ordni async, għaliex Node iħandel concurrency enormi fuq thread wieħed, u r-regola kritika li qatt ma tħallix dak.

Dan huwa fundamentali biex tikteb kod Node korretti u performanti u biex tippuliżza ordni ta' eżekuzzjoni async sorprendenti.