Hva er event loop i Node.js og hvordan fungerer det?

Question

Accepted Answer

**event loop** er mekanismen som gjør at single-threaded Node.js kan utføre **non-blocking I/O**. Det behandler kontinuerlig en kø med callbacks: mens JavaScripten din kjører på én tråd, blir I/O-operasjoner offloadet, og deres callbacks kjøres av løkken når de er ferdige.

## Fasene i løkken

Hver iterasjon ("tick") går gjennom ordnede faser, hver med sin egen callback-kø:

```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 kjøres mellom faser (høy 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)
```

Etter hver fase (og etter synkron kode) tømmer Node **microtasks**: `process.nextTick` callbacks først, deretter Promise callbacks — *før* vi fortsetter. Dette er hvorfor en løst Promise kjøres før `setTimeout(…, 0)`.

## Hvorfor det muliggjør concurrency uten tråder

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

## Kardinalregelen: ikke blokker løkken

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

Å blokkere den ene tråden stopper all request-håndtering. Offload CPU-tungt arbeid til worker threads.

## Hvorfor det er viktig

Event loop er hjertet av Node's ytelsesmodell — forståelse av fasene og microtask-prioriteten forklarer asynk-ordning, hvorfor Node håndterer enorm concurrency på én tråd, og den kritiske regelen for aldri å blokkere det.

Det er grunnleggende for å skrive korrekt, effektiv Node-kode og for å debugge overraskende asynk-utføringsordin.