JavaScript में मेमोरी लीक विस्तार से

JavaScript मेमोरी लीक

JavaScript गार्बेज-कलेक्टेड भाषा है: वेरिएबल्स डिक्लेयर करने पर मेमोरी ऑटो-अलोकेट होती है, रेफरेंस खत्म होने पर ऑटो-फ्री। लीक रिलीज फेज में होती हैं जब अनावश्यक मेमोरी रिलीज नहीं होती।

सामान्य मेमोरी लीक पैटर्न्स

1. अकस्मात ग्लोबल वेरिएबल्स

अनडिक्लेयर्ड वेरिएबल असाइनमेंट ग्लोबल ऑब्जेक्ट (window) पर प्रॉपर्टी बनाता है।

<script>
  // ❌ खराब: 'var/let/const' भूल गए
  function myFunc() {
    leakyVar = "मैं ग्लोबल हूँ!";  // window.leakyVar बन जाता है
  }
  
  // ❌ और खराब: 'this' का गलत उपयोग
  function MyConstructor() {
    this.leaky = "ग्लोबल पर लीक";  // यदि 'new' भूल गए तो this = window
  }
  
  // ✅ सही
  function myFunc() {
    var localVar = "मैं लोकल हूँ";  // फंक्शन खत्म → GC
    let blockVar = "मैं भी लोकल";
    const constVar = "मैं भी";
  }
</script>

2. क्लोजर्स (Closures)

इनर फंक्शन आउटर फंक्शन के स्कोप को "कैप्चर" करता है। यदि आउटर का बड़ा डेटा है और इनर लंबे समय तक जीवित रहता है → लीक।

<script>
  var theThing = null;
  var replaceThing = function() {
    var originalThing = theThing;  // पिछला रेफरेंस रखता है
    var unused = function() {      // यह क्लोजर originalThing रेफर करता है
      if (originalThing) console.log("hi");
    };
    
    theThing = {
      longStr: new Array(1000000).join("*"),  // 1MB डेटा
      someMethod: function() { console.log("message"); }
    };
    
    // 'unused' कभी कॉल नहीं होता लेकिन originalThing को जीवित रखता है
    // हर कॉल पर पिछला theThing (1MB) मेमोरी में रहता है!
  };
  
  setInterval(replaceThing, 1000);  // हर सेकंड 1MB लीक!
</script>

3. भूले हुए टाइमर्स/कॉलबैक्स

<script>
  // ❌ लीक: टाइमर कभी क्लियर नहीं
  var data = getHugeData();
  setInterval(function() {
    // data रेफरेंस्ड रहता है जब तक टाइमर चलता है
    doSomething(data);
  }, 1000);
  
  // ✅ सही: क्लीनअप
  var timer = setInterval(...);
  // जबdone:
  clearInterval(timer);
</script>

4. डिटैच्ड DOM एलिमेंट्स

(पिछले आर्टिकल देखें) - DOM से हटाए गए लेकिन JS रेफरेंस में रखे गए एलिमेंट्स।

5. कंसोल लॉगिंग (डेवलपमेंट में)

<script>
  // DevTools कंसोल ऑब्जेक्ट को रेफरेंस रखता है → GC रोकता है!
  console.log(hugeObject);  // प्रोडक्शन में हटाएं
</script>

मेमोरी लाइफसाइकिल

1. अलोकेशन: वेरिएबल डिक्लेरेशन पर ऑटो
2. उपयोग: रीड/राइट, फंक्शन आर्गुमेंट्स
3. रिलीज: GC तय करता है "अब जरूरत नहीं" - अनडिसाइडेबल समस्या का अनुमान

GC एल्गोरिदम

• रेफरेंस काउंटिंग: सरल, साइकिल्स में फेल
• मार्क-एंड-स्वीप: आधुनिक मानक, साइकिल्स हैंडल करता है
• जनरेशनल/इंक्रीमेंटल: परफॉरमेंस ऑप्टिमाइजेशन

लीक डिटेक्शन टूल्स

• Chrome DevTools → Memory → Heap Snapshots
• Comparison view (स्नैपशॉट्स डिफ)
• Allocation timeline
• performance.memory (डेप्रिकेटेड लेकिन उपयोगी)