JavaScript ਮੈਮੋਰੀ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਬੰਧਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਲੀਕ ਕਿਵੇਂ ਹੁੰਦਾ ਹੈ?

Question

Accepted Answer

JavaScript **ਆਟੋਮੈਟਿਕ ਗਾਰਬੇਜ ਕਲੇਕਸ਼ਨ** ਵਰਤਦਾ ਹੈ। ਕਲੇਕਟਰ **mark-and-sweep** ਐਲਗੋਰਿਦਮ ਵਰਤਦਾ ਹੈ: ਰੂਟ (global object, ਮੌਜੂਦਾ call stack) ਤੋਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, ਇਹ ਹਰ **reachable** ਚੀਜ਼ ਨੂੰ mark ਕਰਦਾ ਹੈ, ਫਿਰ ਹਰ 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, ਜਿੰਦਾ listener, closure, detached DOM node ਜੋ ਅਜਿਹੀ JS ਵਿੱਚ ਹਵਾਲਾ ਹੈ) ਤੋਂ ਹਵਾਲਾ ਕਿਸੇ object ਨੂੰ ਕਲੇਕਟ ਹੋਣ ਤੋਂ ਰੋਕਦਾ ਹੈ।

## ਲੀਕ ਨੂੰ ਡਾਇਗਨੋਜ਼ ਕਰਨਾ

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

ਕਿਸੇ ਕਾਰਵਾਈ ਤੋਂ ਪਹਿਲੇ/ਬਾਅਦ ਵਿੱਚ heap snapshots ਲਓ; ਸਥਿਰਤਾ ਨਾਲ ਵਧਦਾ "retained size" ਯਾਦ ਦਿਵਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਖਾਲੀ ਨਹੀਂ ਹੋ ਰਿਹਾ।

## ਅਸਟਾਰ ਨੂੰ ਪਿੰਨ ਕਰਨ ਤੋਂ ਬਚਣ ਲਈ Tools

```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 ਨੂੰ ਹਟਾਓ, bounded caches (LRU), ਲਿੰਗਰਿੰਗ ਹਵਾਲਿਆਂ ਤੋਂ ਬਚੋ, ਅਤੇ metadata ਲਈ `WeakMap`/`WeakSet` ਵਰਤੋ ਜੋ objects ਨੂੰ ਜਿੰਦਾ ਨਹੀਂ ਰੱਖਣਾ ਚਾਹੀਦਾ।