JavaScript मेमरी कसे व्यवस्थापित करते आणि लीक कसे होते?

Question

Accepted Answer

JavaScript **स्वयंचलित गार्बेज कलेक्शन** वापरते. कलेक्टर **mark-and-sweep** अल्गोरिदम वापरते: रूट्स पासून सुरू करून (ग्लोबल ऑब्जेक्ट, वर्तमान कॉल स्टॅक), तो सर्व काही **रीचेबल** चिन्हांकित करते, मग सर्व अरीचेबल चीज मुक्त करते. तुम्ही कधीही `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
}
```

कोणत्याही रीचेबल जागेचा संदर्भ (एक ग्लोबल, एक लाइव लिसनर, एक क्लोजर, एक डिटॅच केलेला DOM नोड अजून JS मध्ये संदर्भित) ऑब्जेक्टला कलेक्ट होण्यापासून रोखते.

## लीक्स निदान करणे

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

अ‍ॅक्शनपूर्वी/नंतर हीप स्नॅपशॉट घ्या; सतत वाढणारे "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 सर्व्हर) लीक्सपासून क्रॅश होतात किंवा धीमे होतात.

दुरुस्त्या अनुशासित साफसफाई आहेत — लिसनर्स/टाइमर्स काढा, बाउंडेड कॅशेस (LRU), लिंजरिंग संदर्भ टाळा, आणि `WeakMap`/`WeakSet` मेटाडेटासाठी वापरा जे ऑब्जेक्ट्स जीवंत ठेवत नाही.