JavaScript કેવી રીતે મેમરી ચલાવે છે અને લીક્સ કેવી રીતે થાય છે?

Question

Accepted Answer

JavaScript **આપોઆપ કચરો સંગ્રહ** વાપરે છે. સંગ્રાહક **ચિહ્ન-અને-ઝાડવું** અલ્ગોરિધમ વાપરે છે: મૂળ (વૈશ્વિક ઑબ્જેક્ટ, વર્તમાન કૉલ સ્ટેક) થી શરૂ કરીને, તે બધું **પહોંચી શકે તેવું** ચિહ્નિત કરે છે, પછી બધું અપહોંચી શકે તેવું મુક્ત કરે છે. તમે `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
```

ક્રિયા પહેલાં/પછી ગણતરી સ્નેપશોટ લો; સતત વધતું "ધરાયેલું કદ" દર્શાવે છે કે શું મુક્ત નથી કર્યું જાય રહ્યું.

## ઑબ્જેક્ટ્સને પીન કરવાને બચાવવા માટે સાધનો

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

## શા માટે તે મહત્વપૂર્ણ છે

લાંબા ચાલતા apps (SPAs, Node સર્વર્સ) લીક્સ થી ક્રેશ અથવા ધીમું પડે છે.

ફિક્સ ધ્યાનપૂર્વક સફાઈ છે — શ્રોતા/timers દૂર કરો, બંધાયેલ કેશ (LRU), લાંબુ સંદર્ભ ટાળો, અને `WeakMap`/`WeakSet` મેટાડેટા માટે વાપરો જે ઑબ્જેક્ટ્સ જીવંત રાખવું જોઈતું નથી.