Što je event loop u Node.js i kako funkcionira?

Question

Accepted Answer

**Event loop** je mehanizam koji omogućava single-threaded Node.js da izvršava **non-blocking I/O**. Kontinuirano obrađuje red čekanja callback-a: dok se vaš JavaScript izvršava na jednoj niti, I/O operacije se premještaju, a njihovi callback-i se izvršavaju kada se završe.

## Faze petlje

Svaka iteracija ("tick") prolazi kroz uređene faze, od kojih svaka ima svoju red čekanja callback-a:

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

## Microtask-ovi se izvršavaju između faza (visoki prioritet)

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

Nakon svake faze (i nakon sync koda), Node ispunjava **microtask-ove**: prvo `process.nextTick` callback-e, zatim Promise callback-e — *prije* nego što nastavi. Zato se resolved Promise izvršava prije `setTimeout(…, 0)`.

## Kako to omogućava konkurentnost bez niti

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

## Temeljno pravilo: nemoj blokirati petlju

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

Blokiranje jedne niti zaustavlja svu obradu zahtjeva. Preusmjeri CPU-intenzivne radnje na worker niti.

## Zašto je važno

Event loop je srce Node performance modela — razumijevanje njegovih faza i prioriteta microtask-a objašnjava async redoslijed, zašto Node upravlja ogromnom konkurentnosti na jednoj niti, i kritično pravilo nikada ga ne blokirati.

To je fundamentalno za pisanje ispravnog, performantnog Node koda i za debugiranje neočekivanog poretka async izvršavanja.