Kaj je event loop v Node.js in kako deluje?

Question

Accepted Answer

**Event loop** je mehanizem, ki omogoča enotirnem Node.js, da izvršava **neblokirajoč I/O**. Neprekinjeno obdeluje vrsto povratnih klicev: medtem ko se vaš JavaScript izvršava na enem niti, se operacije I/O pretovorijo, njihovi povratni klici pa se izvršijo s pomočjo zanke ob dokončanju.

## Faze zanke

Vsaka iteracija ("tick") poteka skozi urejene faze, vsaka s svojo vrsto povratnih klicev:

```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'i se izvršavajo med fazami (visoka prioriteta)

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

Po vsaki fazi (in po sinhronem kodu) Node izprazni **microtask'e**: povratne klice `process.nextTick` najprej, nato povratne klice Promise — *pred* nadaljevanjem. To je razlog, zakaj se rešena Promise izvršuje pred `setTimeout(…, 0)`.

## Zakaj to omogoča sočasnost brez 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.
```

## Kardinalno pravilo: ne blokiraj zanke

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

Blokiranje ene niti zaustavi vso obdelavo zahtev. Pretovorite CPU-intenzivno delo na delavske niti.

## Zakaj je to pomembno

Event loop je srce modela zmogljivosti Node — razumevanje njegovih faz in prioritete microtask'ov pojasnjuje async-urejanje, zakaj Node obravnava ogromno sočasnost na eni niti in kritično pravilo, da ga nikoli ne blokirate.

To je temeljno za pisanje pravilne, zmogljive kode Node in za odpravljanje presenetljivega vrstnega reda izvršavanja async.