Node.js मा event loop के हो र यो कसरी काम गर्छ?

Question

Accepted Answer

**event loop** एक यन्त्र हो जसले एकल-थ्रेडेड Node.js लाई **non-blocking I/O** प्रदर्शन गर्न सक्षम गर्छ। यो निरन्तर callbacks को एक queue को प्रक्रिया गर्छ: जबकि तपाईको JavaScript एक थ्रेडमा चलिरहेको छ, I/O अपरेशनहरू अलग गरिन्छन्, र यो पूरा भएपछी तिनको callbacks loop द्वारा चलाइन्छ।

## लुपको चरणहरू

प्रत्येक पुनरावृत्ति ("टिक") क्रमबद्ध चरणहरु को माध्यम बाट जान्छ, प्रत्येकको आफ्नै callback queue छ:

```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 चरणहरु बीचमा चलिन्छन् (उच्च प्राथमिकता)

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

प्रत्येक चरण पछि (र sync कोड पछि), Node **microtasks** खाली गर्छ: पहिले `process.nextTick` callbacks, त्यसपछि Promise callbacks — *अगाडि बढ्नु अघि*। यो कारण हो कि एक resolved Promise `setTimeout(…, 0)` भन्दा पहिले चलिन्छ।

## यो थ्रेड बिना concurrency कसरी सक्षम गर्छ

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

## मुख्य नियम: loop लाई ब्लक नगर्नु

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

एकल थ्रेड ब्लक गर्दा सबै अनुरोध प्रबन्धन बन्द हुन्छ। CPU-भारी काम worker threads मा सराउनु।

## यो किन महत्वपूर्ण छ

event loop Node को performance model को हृदय हो — यसको चरणहरु र microtask प्राथमिकता को समझ async क्रमलाई, Node कसरी एक थ्रेडमा विशाल concurrency सम्भाल्छ, र यो कभी ब्लक नगर्ने महत्वपूर्ण नियमलाई व्याख्या गर्छ।

यो सही, प्रभावी Node कोड लेख्न र आश्चर्यजनक async execution क्रमको समस्या समाधान गर्न मौलिक छ।