JavaScript ले मेमोरी कसरी व्यवस्थापन गर्छ र लीक कसरी हुन्छ?

Question

Accepted Answer

JavaScript ले **स्वचालित garbage collection** प्रयोग गर्छ। कलेक्टर **mark-and-sweep** एल्गोरिदम प्रयोग गर्छ: roots (global object, current call stack) बाट सुरु गरेर, यो सबै **reachable** कुरालाई चिन्ह लगाउछ, त्यसपछि सबै unreachable कुरालाई खाली गर्छ। तपाईंले कहिले पनि `free()` म्यानुअली गर्न आवश्यक छैन — तर तपाईंले संदर्भहरू आकस्मिक रूपमा जीवित राख्न सक्नुहुन्छ, जसले लीक गर्न सक्छ।

## चारवटा क्लासिक लीक स्रोत

```js
// 1. Unbounded globals / caches that never shrink
window.cache = window.cache || {};
window.cache[id] = bigObject; // grows forever

// 2. Forgotten event listeners
el.addEventListener("click", handler);
// must call el.removeEventListener("click", handler) when done

// 3. Forgotten timers
const id = setInterval(tick, 1000);
// must clearInterval(id)

// 4. Closures capturing large objects longer than needed
function outer() {
  const huge = new Array(1e6);
  return () => huge.length; // keeps `huge` alive as long as the closure lives
}
```

कुनै पनि reachable स्थानबाट (एक global, एक live listener, एक closure, एक detached DOM node अझै पनि JS मा referenced) एक संदर्भ एक अबजेक्टलाई सङ्कलित हुनबाट रोक्छ।

## लीक निदान गर्दै

```js
performance.memory; // rough heap size (Chrome)
// Chrome DevTools → Memory → take heap snapshots at two points and compare
```

एक कार्य अगाडि/पछाडि heap snapshots लिनुहोस्; एक लगातार बढ्दो "retained size" ले प्रकट गर्छ कि के खाली हुन सकेको छैन।

## अबजेक्टहरू पिन गर्न बेरीबार को उपकरण

```js
const meta = new WeakMap(); // keys are weakly held — GC can collect them
meta.set(domNode, data);    // doesn't prevent domNode from being garbage-collected
```

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

दीर्घ-चलिरहेको अनुप्रयोग (SPAs, Node servers) लीकबाट क्र्यास वा ढिलो हुन्छ।

समाधानहरू अनुशासित सफाइ हुन् — listeners/timers हटाउनुहोस्, bound caches (LRU), lingering references बेरीबार, र `WeakMap`/`WeakSet` प्रयोग गर्नुहोस् metadata को लागि जो अबजेक्टहरूलाई जीवित राखीनदिन सकेको।