ജാവാസ്ക്രിപ്റ്റ് വീക്ക്മാപ്പും വീക്ക്സെറ്റും: മെമ്മറി-കാര്യക്ഷമമായ കളക്ഷനുകളിൽ വൈദഗ്ദ്ധ്യം നേടാം

ഡാറ്റയുടെ കളക്ഷനുകൾ കൈകാര്യം ചെയ്യുന്നതിനായി ജാവാസ്ക്രിപ്റ്റിൽ നിരവധി ഡാറ്റാ സ്ട്രക്ച്ചറുകൾ ലഭ്യമാണ്. സാധാരണ Map, Set എന്നിവ ശക്തമായ ടൂളുകൾ നൽകുമ്പോൾ, ചിലപ്പോൾ അവ മെമ്മറി ലീക്കുകളിലേക്ക് നയിച്ചേക്കാം, പ്രത്യേകിച്ച് സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകളിൽ. ഇവിടെയാണ് WeakMap, WeakSet എന്നിവ പ്രസക്തമാകുന്നത്. ഈ പ്രത്യേക കളക്ഷനുകൾ മെമ്മറി മാനേജ്മെന്റിന് ഒരു പുതിയ സമീപനം നൽകുന്നു, ജാവാസ്ക്രിപ്റ്റിന്റെ ഗാർബേജ് കളക്ടറിന് മെമ്മറി കൂടുതൽ കാര്യക്ഷമമായി വീണ്ടെടുക്കാൻ സഹായിക്കുന്നു.

പ്രശ്നം മനസ്സിലാക്കാം: സ്ട്രോങ്ങ് റഫറൻസുകൾ

WeakMap, WeakSet എന്നിവയെക്കുറിച്ച് പഠിക്കുന്നതിന് മുമ്പ്, നമുക്ക് പ്രധാന പ്രശ്നം മനസ്സിലാക്കാം: സ്ട്രോങ്ങ് റഫറൻസുകൾ. ജാവാസ്ക്രിപ്റ്റിൽ, ഒരു ഒബ്ജക്റ്റ് ഒരു Map-ലെ കീ ആയോ അല്ലെങ്കിൽ ഒരു Set-ലെ വാല്യൂ ആയോ സ്റ്റോർ ചെയ്യുമ്പോൾ, ആ കളക്ഷൻ ആ ഒബ്ജക്റ്റിലേക്ക് ഒരു സ്ട്രോങ്ങ് റഫറൻസ് നിലനിർത്തുന്നു. ഇതിനർത്ഥം, Map അല്ലെങ്കിൽ Set നിലനിൽക്കുന്നിടത്തോളം കാലം, നിങ്ങളുടെ കോഡിൽ മറ്റൊരിടത്തും ആ ഒബ്ജക്റ്റിന് റഫറൻസ് ഇല്ലെങ്കിൽ പോലും, ഗാർബേജ് കളക്ടറിന് ആ ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്ന മെമ്മറി വീണ്ടെടുക്കാൻ കഴിയില്ല. ഇത് മെമ്മറി ലീക്കുകളിലേക്ക് നയിച്ചേക്കാം, പ്രത്യേകിച്ച് വലുതും ദീർഘകാലം നിലനിൽക്കുന്നതുമായ കളക്ഷനുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ.

ഈ ഉദാഹരണം പരിഗണിക്കുക:

            let myMap = new Map();
let key = { id: 1, name: "Example Object" };

myMap.set(key, "Some value");

// Even if 'key' is no longer used directly...
key = null;

// ... the Map still holds a reference to it.
console.log(myMap.size); // Output: 1

            

              
                Copy
              
            
          

ഈ സാഹചര്യത്തിൽ, key എന്നതിനെ null ആക്കി മാറ്റിയ ശേഷവും, Map യഥാർത്ഥ ഒബ്ജക്റ്റിലേക്കുള്ള റഫറൻസ് നിലനിർത്തുന്നു. ഗാർബേജ് കളക്ടറിന് ആ ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്ന മെമ്മറി വീണ്ടെടുക്കാൻ കഴിയില്ല, കാരണം Map അത് തടയുന്നു.

വീക്ക്മാപ്പും വീക്ക്സെറ്റും പരിചയപ്പെടാം: രക്ഷകരായി വീക്ക് റഫറൻസുകൾ

WeakMap-ഉം WeakSet-ഉം ഈ പ്രശ്നം പരിഹരിക്കുന്നത് വീക്ക് റഫറൻസുകൾ ഉപയോഗിച്ചാണ്. ഒരു വീക്ക് റഫറൻസ്, ഒരു ഒബ്ജക്റ്റിന് മറ്റ് സ്ട്രോങ്ങ് റഫറൻസുകൾ ഇല്ലെങ്കിൽ, അതിനെ ഗാർബേജ് കളക്ട് ചെയ്യാൻ അനുവദിക്കുന്നു. ഒരു WeakMap-ലെ കീ അല്ലെങ്കിൽ WeakSet-ലെ വാല്യൂ വീക്ക് റഫറൻസിലൂടെ മാത്രം ബന്ധിപ്പിക്കപ്പെട്ടിരിക്കുമ്പോൾ, ഗാർബേജ് കളക്ടറിന് ആ മെമ്മറി വീണ്ടെടുക്കാൻ സ്വാതന്ത്ര്യമുണ്ട്. ഒബ്ജക്റ്റ് ഗാർബേജ് കളക്ട് ചെയ്തുകഴിഞ്ഞാൽ, അതിന് അനുബന്ധമായ എൻട്രി WeakMap-ൽ നിന്നോ WeakSet-ൽ നിന്നോ സ്വയമേവ നീക്കം ചെയ്യപ്പെടുന്നു.

വീക്ക്മാപ്പ്: വീക്ക് കീകൾ ഉള്ള കീ-വാല്യൂ ജോഡികൾ

ഒരു WeakMap എന്നത് കീ-വാല്യൂ ജോഡികളുടെ ഒരു ശേഖരമാണ്, ഇവിടെ കീകൾ ഒബ്ജക്റ്റുകൾ ആയിരിക്കണം. കീകൾ വീക്ക് ആയി സൂക്ഷിക്കപ്പെടുന്നു, അതായത് ഒരു കീ ഒബ്ജക്റ്റിന് മറ്റൊരിടത്തും റഫറൻസ് ഇല്ലെങ്കിൽ, അത് ഗാർബേജ് കളക്ട് ചെയ്യപ്പെടുകയും WeakMap-ലെ അനുബന്ധ എൻട്രി നീക്കം ചെയ്യപ്പെടുകയും ചെയ്യും. എന്നാൽ വാല്യൂകൾ സാധാരണ (സ്ട്രോങ്ങ്) റഫറൻസുകളോടെയാണ് സൂക്ഷിക്കപ്പെടുന്നത്.

ഒരു അടിസ്ഥാന ഉദാഹരണം ഇതാ:

            let weakMap = new WeakMap();
let key = { id: 1, name: "WeakMap Key" };
let value = "Associated Data";

weakMap.set(key, value);

console.log(weakMap.get(key)); // Output: "Associated Data"

key = null;

// After garbage collection (which is not guaranteed to happen immediately)...
// weakMap.get(key) might return undefined.  This is implementation-dependent.
// We can't directly observe when an entry is removed from a WeakMap, which is by design.

            

              
                Copy
              
            
          

Map-ൽ നിന്നുള്ള പ്രധാന വ്യത്യാസങ്ങൾ:

• കീകൾ ഒബ്ജക്റ്റുകളായിരിക്കണം: WeakMap-ൽ കീകൾ ആയി ഒബ്ജക്റ്റുകൾ മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ. പ്രിമിറ്റീവ് വാല്യൂകൾ (സ്ട്രിംഗുകൾ, നമ്പറുകൾ, ബൂളിയനുകൾ, സിംബലുകൾ) അനുവദനീയമല്ല. കാരണം, പ്രിമിറ്റീവ് വാല്യൂകൾ മാറ്റമില്ലാത്തവയാണ്, ഒബ്ജക്റ്റുകൾ പോലെ അവയ്ക്ക് ഗാർബേജ് കളക്ഷൻ ആവശ്യമില്ല.
• ഇറ്ററേഷൻ ഇല്ല: WeakMap-ലെ കീകൾ, വാല്യൂകൾ, അല്ലെങ്കിൽ എൻട്രികൾ എന്നിവയിലൂടെ നിങ്ങൾക്ക് ഇറ്ററേറ്റ് ചെയ്യാൻ കഴിയില്ല. forEach, keys(), values(), അല്ലെങ്കിൽ entries() പോലുള്ള മെത്തേഡുകൾ ഇല്ല. കാരണം, ഈ മെത്തേഡുകളുടെ സാന്നിധ്യം WeakMap-ന് അതിന്റെ കീകൾക്ക് ഒരു സ്ട്രോങ്ങ് റഫറൻസ് നിലനിർത്തേണ്ടി വരും, ഇത് വീക്ക് റഫറൻസുകളുടെ ഉദ്ദേശ്യത്തെ പരാജയപ്പെടുത്തുന്നു.
• സൈസ് പ്രോപ്പർട്ടി ഇല്ല: WeakMap-ന് size പ്രോപ്പർട്ടി ഇല്ല. സൈസ് നിർണ്ണയിക്കുന്നതിനും കീകൾ ഇറ്ററേറ്റ് ചെയ്യേണ്ടി വരും, അത് അനുവദനീയമല്ല.
• പരിമിതമായ മെത്തേഡുകൾ: WeakMap get(key), set(key, value), has(key), delete(key) എന്നിവ മാത്രമേ നൽകുന്നുള്ളൂ.

വീക്ക്സെറ്റ്: വീക്ക് ആയി സൂക്ഷിക്കുന്ന ഒബ്ജക്റ്റുകളുടെ ഒരു ശേഖരം

ഒരു WeakSet ഒരു Set-ന് സമാനമാണ്, പക്ഷേ ഇത് ഒബ്ജക്റ്റുകൾ മാത്രം വാല്യൂകളായി സംഭരിക്കാൻ അനുവദിക്കുന്നു. WeakMap-നെപ്പോലെ, WeakSet-ഉം ഈ ഒബ്ജക്റ്റുകളെ വീക്ക് ആയി സൂക്ഷിക്കുന്നു. ഒരു WeakSet-ലെ ഒബ്ജക്റ്റിന് മറ്റൊരിടത്തും സ്ട്രോങ്ങ് റഫറൻസ് ഇല്ലെങ്കിൽ, അത് ഗാർബേജ് കളക്ട് ചെയ്യപ്പെടുകയും WeakSet ആ ഒബ്ജക്റ്റിനെ സ്വയമേവ നീക്കം ചെയ്യുകയും ചെയ്യും.

ലളിതമായ ഒരു ഉദാഹരണം ഇതാ:

            let weakSet = new WeakSet();
let obj1 = { id: 1, name: "Object 1" };
let obj2 = { id: 2, name: "Object 2" };

weakSet.add(obj1);
weakSet.add(obj2);

console.log(weakSet.has(obj1)); // Output: true

obj1 = null;

// After garbage collection (not guaranteed immediately)...
// weakSet.has(obj1) might return false.  This is implementation-dependent.
// We cannot directly observe when an element is removed from a WeakSet.

            

              
                Copy
              
            
          

Set-ൽ നിന്നുള്ള പ്രധാന വ്യത്യാസങ്ങൾ:

• വാല്യൂകൾ ഒബ്ജക്റ്റുകളായിരിക്കണം: WeakSet-ൽ ഒബ്ജക്റ്റുകൾ മാത്രമേ സംഭരിക്കാൻ കഴിയൂ. പ്രിമിറ്റീവ് വാല്യൂകൾ അനുവദനീയമല്ല.
• ഇറ്ററേഷൻ ഇല്ല: നിങ്ങൾക്ക് ഒരു WeakSet-ലൂടെ ഇറ്ററേറ്റ് ചെയ്യാൻ കഴിയില്ല. ഇതിൽ forEach മെത്തേഡോ മറ്റ് ഘടകങ്ങളെ ആക്സസ് ചെയ്യാനുള്ള മാർഗ്ഗങ്ങളോ ഇല്ല.
• സൈസ് പ്രോപ്പർട്ടി ഇല്ല: WeakSet-ന് size പ്രോപ്പർട്ടി ഇല്ല.
• പരിമിതമായ മെത്തേഡുകൾ: WeakSet add(value), has(value), delete(value) എന്നിവ മാത്രമേ നൽകുന്നുള്ളൂ.

വീക്ക്മാപ്പിനും വീക്ക്സെറ്റിനുമുള്ള പ്രായോഗിക ഉപയോഗങ്ങൾ

WeakMap, WeakSet എന്നിവയുടെ പരിമിതികൾ അവയെ അവയുടെ സ്ട്രോങ്ങ് പതിപ്പുകളേക്കാൾ ഉപയോഗയോഗ്യമല്ലെന്ന് തോന്നിച്ചേക്കാം. എന്നിരുന്നാലും, അവയുടെ സവിശേഷമായ മെമ്മറി മാനേജ്മെന്റ് കഴിവുകൾ ചില പ്രത്യേക സാഹചര്യങ്ങളിൽ അവയെ വിലപ്പെട്ടതാക്കുന്നു.

1. DOM എലമെന്റ് മെറ്റാഡാറ്റ

ഒരു സാധാരണ ഉപയോഗം, DOM-നെ മലിനമാക്കാതെ DOM എലമെന്റുകളുമായി മെറ്റാഡാറ്റ ബന്ധിപ്പിക്കുക എന്നതാണ്. ഉദാഹരണത്തിന്, ഒരു പ്രത്യേക HTML എലമെന്റുമായി ബന്ധപ്പെട്ട കമ്പോണന്റ്-സ്പെസിഫിക് ഡാറ്റ സംഭരിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഒരു WeakMap ഉപയോഗിക്കുന്നതിലൂടെ, DOM എലമെന്റ് പേജിൽ നിന്ന് നീക്കം ചെയ്യുമ്പോൾ, അതുമായി ബന്ധപ്പെട്ട മെറ്റാഡാറ്റയും ഗാർബേജ് കളക്ട് ചെയ്യപ്പെടുമെന്ന് ഉറപ്പാക്കാം, ഇത് മെമ്മറി ലീക്കുകൾ തടയുന്നു.

            let elementData = new WeakMap();

function initializeComponent(element) {
  let componentData = {
    // Component-specific data
    isActive: false,
    onClick: () => { console.log("Clicked!"); }
  };
  elementData.set(element, componentData);
}

let myElement = document.getElementById("myElement");
initializeComponent(myElement);

// Later, when the element is removed from the DOM:
// myElement.remove();

// The componentData associated with myElement will eventually be garbage collected
// when there are no other strong references to myElement.

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, elementData DOM എലമെന്റുകളുമായി ബന്ധപ്പെട്ട മെറ്റാഡാറ്റ സംഭരിക്കുന്നു. myElement DOM-ൽ നിന്ന് നീക്കം ചെയ്യപ്പെടുമ്പോൾ, ഗാർബേജ് കളക്ടറിന് അതിന്റെ മെമ്മറി വീണ്ടെടുക്കാൻ കഴിയും, കൂടാതെ elementData-ലെ അനുബന്ധ എൻട്രി സ്വയമേവ നീക്കം ചെയ്യപ്പെടുന്നു.

2. സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങളുടെ ഫലങ്ങൾ കാഷെ ചെയ്യൽ

ഇൻപുട്ട് ഒബ്ജക്റ്റുകളെ അടിസ്ഥാനമാക്കി സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങളുടെ ഫലങ്ങൾ കാഷെ ചെയ്യാൻ നിങ്ങൾക്ക് ഒരു WeakMap ഉപയോഗിക്കാം. ഒരു ഇൻപുട്ട് ഒബ്ജക്റ്റ് ഇനി ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, കാഷെ ചെയ്ത ഫലം WeakMap-ൽ നിന്ന് സ്വയമേവ നീക്കം ചെയ്യപ്പെടുകയും മെമ്മറി സ്വതന്ത്രമാവുകയും ചെയ്യും.

            let cache = new WeakMap();

function expensiveOperation(input) {
  if (cache.has(input)) {
    console.log("Cache hit!");
    return cache.get(input);
  }

  console.log("Cache miss!");
  // Perform the expensive operation
  let result = input.id * 100;

  cache.set(input, result);
  return result;
}

let obj1 = { id: 5 };
let obj2 = { id: 10 };

console.log(expensiveOperation(obj1)); // Output: Cache miss!, 500
console.log(expensiveOperation(obj1)); // Output: Cache hit!, 500
console.log(expensiveOperation(obj2)); // Output: Cache miss!, 1000

obj1 = null;

// After garbage collection, the entry for obj1 will be removed from the cache.

            

              
                Copy
              
            
          

3. ഒബ്ജക്റ്റുകൾക്കുള്ള സ്വകാര്യ ഡാറ്റ (പ്രൈവറ്റ് ഫീൽഡുകളായി വീക്ക്മാപ്പ്)

ജാവാസ്ക്രിപ്റ്റിൽ പ്രൈവറ്റ് ക്ലാസ് ഫീൽഡുകൾ അവതരിപ്പിക്കുന്നതിന് മുമ്പ്, ഒബ്ജക്റ്റുകൾക്കുള്ളിൽ പ്രൈവറ്റ് ഡാറ്റ സിമുലേറ്റ് ചെയ്യുന്നതിനുള്ള ഒരു സാധാരണ രീതിയായിരുന്നു WeakMap ഉപയോഗിക്കുന്നത്. ഓരോ ഒബ്ജക്റ്റും അതിന്റേതായ പ്രൈവറ്റ് ഡാറ്റയുമായി ബന്ധിപ്പിക്കപ്പെടും, അത് ഒരു WeakMap-ൽ സൂക്ഷിക്കും. ഡാറ്റ WeakMap-ലൂടെയും ഒബ്ജക്റ്റിലൂടെയും മാത്രം ആക്സസ് ചെയ്യാൻ കഴിയുന്നതിനാൽ, ഇത് ഫലപ്രദമായി പ്രൈവറ്റ് ആയിരിക്കും.

            let _privateData = new WeakMap();

class MyClass {
  constructor(secret) {
    _privateData.set(this, { secret: secret });
  }

  getSecret() {
    return _privateData.get(this).secret;
  }
}

let instance = new MyClass("My Secret Value");
console.log(instance.getSecret()); // Output: My Secret Value

// Trying to access _privateData directly will not work.
// console.log(_privateData.get(instance).secret); // Error (if you somehow had access to _privateData)

// Even if the instance is garbage collected, the corresponding entry in _privateData will be removed.

            

              
                Copy
              
            
          

ഇപ്പോൾ പ്രൈവറ്റ് ക്ലാസ് ഫീൽഡുകളാണ് അഭികാമ്യമായ സമീപനമെങ്കിലും, ഈ WeakMap പാറ്റേൺ മനസ്സിലാക്കുന്നത് പഴയ കോഡുകൾക്കും ജാവാസ്ക്രിപ്റ്റിന്റെ ചരിത്രം മനസ്സിലാക്കുന്നതിനും ഇപ്പോഴും വിലപ്പെട്ടതാണ്.

4. ഒബ്ജക്റ്റ് ലൈഫ് സൈക്കിൾ ട്രാക്ക് ചെയ്യൽ

ഒബ്ജക്റ്റുകളുടെ ലൈഫ് സൈക്കിൾ ട്രാക്ക് ചെയ്യാൻ WeakSet ഉപയോഗിക്കാം. ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുമ്പോൾ അവയെ ഒരു WeakSet-ലേക്ക് ചേർക്കാനും, പിന്നീട് അവ WeakSet-ൽ ഇപ്പോഴും ഉണ്ടോ എന്ന് പരിശോധിക്കാനും കഴിയും. ഒരു ഒബ്ജക്റ്റ് ഗാർബേജ് കളക്ട് ചെയ്യപ്പെടുമ്പോൾ, അത് WeakSet-ൽ നിന്ന് സ്വയമേവ നീക്കം ചെയ്യപ്പെടും.

            let trackedObjects = new WeakSet();

function trackObject(obj) {
  trackedObjects.add(obj);
}

function isObjectTracked(obj) {
  return trackedObjects.has(obj);
}

let myObject = { id: 123 };
trackObject(myObject);

console.log(isObjectTracked(myObject)); // Output: true

myObject = null;

// After garbage collection, isObjectTracked(myObject) might return false.

            

              
                Copy
              
            
          

പൊതുവായ പരിഗണനകളും മികച്ച രീതികളും

WeakMap, WeakSet എന്നിവയുമായി പ്രവർത്തിക്കുമ്പോൾ, ഈ പൊതുവായ മികച്ച രീതികൾ പരിഗണിക്കുക:

• ഗാർബേജ് കളക്ഷൻ മനസ്സിലാക്കുക: ഗാർബേജ് കളക്ഷൻ എപ്പോൾ നടക്കുമെന്ന് കൃത്യമായി പ്രവചിക്കാൻ കഴിയില്ല. അതിനാൽ, ഒരു ഒബ്ജക്റ്റിന് റഫറൻസ് ഇല്ലാതാകുമ്പോൾ തന്നെ എൻട്രികൾ നീക്കം ചെയ്യാൻ WeakMap അല്ലെങ്കിൽ WeakSet ആശ്രയിക്കാൻ കഴിയില്ല.
• അമിത ഉപയോഗം ഒഴിവാക്കുക: WeakMap, WeakSet എന്നിവ മെമ്മറി മാനേജ്മെന്റിന് ഉപയോഗപ്രദമാണെങ്കിലും, അവ അമിതമായി ഉപയോഗിക്കരുത്. പല സാഹചര്യങ്ങളിലും, സാധാരണ Map, Set എന്നിവ തികച്ചും അനുയോജ്യവും കൂടുതൽ സൗകര്യപ്രദവുമാണ്. മെമ്മറി ലീക്കുകൾ ഒഴിവാക്കാൻ നിങ്ങൾക്ക് പ്രത്യേകമായി വീക്ക് റഫറൻസുകൾ ആവശ്യമുള്ളപ്പോൾ WeakMap, WeakSet എന്നിവ ഉപയോഗിക്കുക.
• വീക്ക് റഫറൻസുകളുടെ ഉപയോഗങ്ങൾ: നിങ്ങൾ കീ ആയി (WeakMap-ന്) അല്ലെങ്കിൽ വാല്യൂ ആയി (WeakSet-ന്) സംഭരിക്കുന്ന ഒബ്ജക്റ്റിന്റെ ലൈഫ് ടൈമിനെക്കുറിച്ച് ചിന്തിക്കുക. ഒബ്ജക്റ്റ് മറ്റൊരു ഒബ്ജക്റ്റിന്റെ ലൈഫ് സൈക്കിളുമായി ബന്ധപ്പെട്ടിട്ടുണ്ടെങ്കിൽ, മെമ്മറി ലീക്കുകൾ ഒഴിവാക്കാൻ WeakMap അല്ലെങ്കിൽ WeakSet ഉപയോഗിക്കുക.
• ടെസ്റ്റിംഗിലെ വെല്ലുവിളികൾ: ഗാർബേജ് കളക്ഷനെ ആശ്രയിക്കുന്ന കോഡ് ടെസ്റ്റ് ചെയ്യുന്നത് വെല്ലുവിളിയാകാം. നിങ്ങൾക്ക് ജാവാസ്ക്രിപ്റ്റിൽ ഗാർബേജ് കളക്ഷൻ നിർബന്ധിച്ച് നടത്താൻ കഴിയില്ല. ടെസ്റ്റിംഗിനിടെ ഗാർബേജ് കളക്ഷനെ പ്രോത്സാഹിപ്പിക്കുന്നതിന് ധാരാളം ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുകയും നശിപ്പിക്കുകയും ചെയ്യുന്ന പോലുള്ള ടെക്നിക്കുകൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.
• പോളിഫില്ലിംഗ്: WeakMap, WeakSet എന്നിവ നേറ്റീവ് ആയി പിന്തുണയ്ക്കാത്ത പഴയ ബ്രൗസറുകളെ നിങ്ങൾ പിന്തുണയ്ക്കണമെങ്കിൽ, പോളിഫില്ലുകൾ ഉപയോഗിക്കാം. എന്നിരുന്നാലും, പോളിഫില്ലുകൾക്ക് വീക്ക് റഫറൻസ് സ്വഭാവം പൂർണ്ണമായി അനുകരിക്കാൻ കഴിഞ്ഞേക്കില്ല, അതിനാൽ നന്നായി ടെസ്റ്റ് ചെയ്യുക.

ഉദാഹരണം: ഇന്റർനാഷണലൈസേഷൻ (i18n) കാഷെ

നിങ്ങൾ ഇന്റർനാഷണലൈസേഷൻ (i18n) പിന്തുണയോടെ ഒരു വെബ് ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്ന ഒരു സാഹചര്യം സങ്കൽപ്പിക്കുക. ഉപയോക്താവിന്റെ ലോക്കേലിനെ അടിസ്ഥാനമാക്കി വിവർത്തനം ചെയ്ത സ്ട്രിംഗുകൾ കാഷെ ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. കാഷെ സംഭരിക്കുന്നതിന് നിങ്ങൾക്ക് ഒരു WeakMap ഉപയോഗിക്കാം, ഇവിടെ കീ ലോക്കേൽ ഒബ്ജക്റ്റും വാല്യൂ ആ ലോക്കേലിനുള്ള വിവർത്തനം ചെയ്ത സ്ട്രിംഗുകളുമായിരിക്കും. ഒരു ലോക്കേൽ ഇനി ആവശ്യമില്ലാതാകുമ്പോൾ (ഉദാഹരണത്തിന്, ഉപയോക്താവ് മറ്റൊരു ഭാഷയിലേക്ക് മാറുകയും പഴയ ലോക്കേലിന് റഫറൻസ് ഇല്ലാതാവുകയും ചെയ്യുമ്പോൾ), ആ ലോക്കേലിനുള്ള കാഷെ സ്വയമേവ ഗാർബേജ് കളക്ട് ചെയ്യപ്പെടും.

            let i18nCache = new WeakMap();

function getTranslatedStrings(locale) {
  if (i18nCache.has(locale)) {
    return i18nCache.get(locale);
  }

  // Simulate fetching translated strings from a server.
  let translatedStrings = {
    "greeting": (locale.language === "fr") ? "Bonjour" : "Hello",
    "farewell": (locale.language === "fr") ? "Au revoir" : "Goodbye"
  };

  i18nCache.set(locale, translatedStrings);
  return translatedStrings;
}

let englishLocale = { language: "en", country: "US" };
let frenchLocale = { language: "fr", country: "FR" };

console.log(getTranslatedStrings(englishLocale).greeting); // Output: Hello
console.log(getTranslatedStrings(frenchLocale).greeting);  // Output: Bonjour

englishLocale = null;

// After garbage collection, the entry for englishLocale will be removed from the cache.

            

              
                Copy
              
            
          

ഈ സമീപനം i18n കാഷെ അനിശ്ചിതമായി വളർന്ന് അമിതമായ മെമ്മറി ഉപയോഗിക്കുന്നത് തടയുന്നു, പ്രത്യേകിച്ച് ധാരാളം ലോക്കേലുകളെ പിന്തുണയ്ക്കുന്ന ആപ്ലിക്കേഷനുകളിൽ.

ഉപസംഹാരം

WeakMap, WeakSet എന്നിവ ജാവാസ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകളിൽ മെമ്മറി കൈകാര്യം ചെയ്യുന്നതിനുള്ള ശക്തമായ ടൂളുകളാണ്. അവയുടെ പരിമിതികളും ഉപയോഗങ്ങളും മനസ്സിലാക്കുന്നതിലൂടെ, മെമ്മറി ലീക്കുകൾ ഒഴിവാക്കുന്ന കൂടുതൽ കാര്യക്ഷമവും ശക്തവുമായ കോഡ് നിങ്ങൾക്ക് എഴുതാൻ കഴിയും. എല്ലാ സാഹചര്യങ്ങൾക്കും അവ അനുയോജ്യമല്ലായിരിക്കാം, എന്നാൽ ഒബ്ജക്റ്റുകളെ ഗാർബേജ് കളക്ട് ചെയ്യുന്നതിൽ നിന്ന് തടയാതെ അവയുമായി ഡാറ്റ ബന്ധിപ്പിക്കേണ്ട സാഹചര്യങ്ങളിൽ അവ അത്യന്താപേക്ഷിതമാണ്. നിങ്ങളുടെ ജാവാസ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകൾ ഒപ്റ്റിമൈസ് ചെയ്യാനും ലോകത്തെവിടെയുമുള്ള നിങ്ങളുടെ ഉപയോക്താക്കൾക്ക് മികച്ച അനുഭവം നൽകാനും ഈ കളക്ഷനുകൾ ഉപയോഗിക്കുക.