ജാവാസ്ക്രിപ്റ്റ് ക്ലോഷറുകൾ: പ്രായോഗിക ഉദാഹരണങ്ങളിലൂടെ ലളിതമായി വിശദീകരിക്കുന്നു

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

എന്താണ് ഒരു ക്ലോഷർ?

ലളിതമായി പറഞ്ഞാൽ, ഒരു ഫംഗ്ഷനും ആ ഫംഗ്ഷൻ പ്രഖ്യാപിച്ച ലെക്സിക്കൽ എൻവയോൺമെൻ്റും ചേർന്നതാണ് ഒരു ക്ലോഷർ. ഇതിനർത്ഥം, പുറമെയുള്ള ഫംഗ്ഷൻ്റെ പ്രവർത്തനം പൂർത്തിയായ ശേഷവും, അതിൻ്റെ ചുറ്റുമുള്ള സ്കോപ്പിൽ നിന്നുള്ള വേരിയബിളുകൾ ആക്സസ് ചെയ്യാൻ ഒരു ക്ലോഷർ ഒരു ഫംഗ്ഷനെ അനുവദിക്കുന്നു. ഉള്ളിലുള്ള ഫംഗ്ഷൻ അതിൻ്റെ പരിസ്ഥിതിയെ "ഓർമ്മിക്കുന്നു" എന്ന് കരുതുക.

ഇത് ശരിക്കും മനസ്സിലാക്കാൻ, നമുക്ക് പ്രധാന ഘടകങ്ങളെ വിഭജിക്കാം:

• ഫംഗ്ഷൻ: ക്ലോഷറിൻ്റെ ഭാഗമാകുന്ന ആന്തരിക ഫംഗ്ഷൻ.
• ലെക്സിക്കൽ എൻവയോൺമെൻ്റ്: ഫംഗ്ഷൻ പ്രഖ്യാപിച്ച ചുറ്റുമുള്ള സ്കോപ്പ്. ഇതിൽ വേരിയബിളുകൾ, ഫംഗ്ഷനുകൾ, മറ്റ് ഡിക്ലറേഷനുകൾ എന്നിവ ഉൾപ്പെടുന്നു.

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

എന്തുകൊണ്ടാണ് ക്ലോഷറുകൾ പ്രധാനമാകുന്നത്?

ക്ലോഷറുകൾ ഒരു സൈദ്ധാന്തിക ആശയം മാത്രമല്ല; ജാവാസ്ക്രിപ്റ്റിലെ പല സാധാരണ പ്രോഗ്രാമിംഗ് പാറ്റേണുകൾക്കും അവ അത്യാവശ്യമാണ്. അവ ഇനിപ്പറയുന്ന പ്രയോജനങ്ങൾ നൽകുന്നു:

• ഡാറ്റാ എൻക്യാപ്‌സുലേഷൻ: സ്വകാര്യ വേരിയബിളുകളും മെത്തേഡുകളും സൃഷ്ടിക്കാൻ ക്ലോഷറുകൾ നിങ്ങളെ അനുവദിക്കുന്നു, അതുവഴി പുറത്തുനിന്നുള്ള ആക്‌സസ്സിൽ നിന്നും മാറ്റം വരുത്തുന്നതിൽ നിന്നും ഡാറ്റയെ സംരക്ഷിക്കുന്നു.
• സ്റ്റേറ്റ് സംരക്ഷണം: ഫംഗ്ഷൻ കോളുകൾക്കിടയിൽ വേരിയബിളുകളുടെ അവസ്ഥ ക്ലോഷറുകൾ നിലനിർത്തുന്നു, ഇത് കൗണ്ടറുകൾ, ടൈമറുകൾ, മറ്റ് സ്റ്റേറ്റ്ഫുൾ ഘടകങ്ങൾ എന്നിവ സൃഷ്ടിക്കാൻ ഉപയോഗപ്രദമാണ്.
• ഹയർ-ഓർഡർ ഫംഗ്ഷനുകൾ: മറ്റ് ഫംഗ്ഷനുകളെ ആർഗ്യുമെൻ്റുകളായി എടുക്കുകയോ ഫംഗ്ഷനുകളെ തിരികെ നൽകുകയോ ചെയ്യുന്ന ഹയർ-ഓർഡർ ഫംഗ്ഷനുകളുമായി ചേർത്താണ് ക്ലോഷറുകൾ പലപ്പോഴും ഉപയോഗിക്കുന്നത്, ഇത് ശക്തവും വഴക്കമുള്ളതുമായ കോഡ് സാധ്യമാക്കുന്നു.
• അസിൻക്രണസ് ജാവാസ്ക്രിപ്റ്റ്: കോൾബാക്കുകളും പ്രോമിസുകളും പോലുള്ള അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിൽ ക്ലോഷറുകൾ ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു.

ജാവാസ്ക്രിപ്റ്റ് ക്ലോഷറുകളുടെ പ്രായോഗിക ഉദാഹരണങ്ങൾ

ക്ലോഷറുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും യഥാർത്ഥ സാഹചര്യങ്ങളിൽ അവ എങ്ങനെ ഉപയോഗിക്കാമെന്നും വ്യക്തമാക്കാൻ ചില പ്രായോഗിക ഉദാഹരണങ്ങളിലേക്ക് കടക്കാം.

ഉദാഹരണം 1: ലളിതമായ കൗണ്ടർ

ഫംഗ്ഷൻ കോളുകൾക്കിടയിൽ അതിൻ്റെ സ്റ്റേറ്റ് നിലനിർത്തുന്ന ഒരു കൗണ്ടർ ഉണ്ടാക്കാൻ ഒരു ക്ലോഷർ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു.

function createCounter() {
  let count = 0;

  return function() {
    count++;
    console.log(count);
  };
}

const increment = createCounter();

increment(); // Output: 1
increment(); // Output: 2
increment(); // Output: 3

വിശദീകരണം:

• createCounter() എന്നത് count എന്ന വേരിയബിൾ പ്രഖ്യാപിക്കുന്ന ഒരു പുറമെയുള്ള ഫംഗ്ഷനാണ്.
• ഇത് count-ൻ്റെ മൂല്യം വർദ്ധിപ്പിക്കുകയും ലോഗ് ചെയ്യുകയും ചെയ്യുന്ന ഒരു ആന്തരിക ഫംഗ്ഷനെ (ഈ സാഹചര്യത്തിൽ ഒരു അജ്ഞാത ഫംഗ്ഷൻ) തിരികെ നൽകുന്നു.
• ആന്തരിക ഫംഗ്ഷൻ count വേരിയബിളിന്മേൽ ഒരു ക്ലോഷർ രൂപീകരിക്കുന്നു.
• createCounter()-ൻ്റെ പ്രവർത്തനം പൂർത്തിയായ ശേഷവും, ആന്തരിക ഫംഗ്ഷന് count വേരിയബിളിലേക്ക് ആക്സസ് നിലനിൽക്കുന്നു.
• increment()-ലേക്കുള്ള ഓരോ കോളും ഒരേ count വേരിയബിളിനെ വർദ്ധിപ്പിക്കുന്നു, ഇത് സ്റ്റേറ്റ് സംരക്ഷിക്കാനുള്ള ക്ലോഷറിൻ്റെ കഴിവ് വ്യക്തമാക്കുന്നു.

ഉദാഹരണം 2: പ്രൈവറ്റ് വേരിയബിളുകൾ ഉപയോഗിച്ച് ഡാറ്റാ എൻക്യാപ്‌സുലേഷൻ

സ്വകാര്യ വേരിയബിളുകൾ സൃഷ്ടിക്കാൻ ക്ലോഷറുകൾ ഉപയോഗിക്കാം, ഇത് ഫംഗ്ഷന് പുറത്തുനിന്നുള്ള നേരിട്ടുള്ള ആക്‌സസ്സിൽ നിന്നും മാറ്റം വരുത്തുന്നതിൽ നിന്നും ഡാറ്റയെ സംരക്ഷിക്കുന്നു.

function createBankAccount(initialBalance) {
  let balance = initialBalance;

  return {
    deposit: function(amount) {
      balance += amount;
      return balance; //Returning for demonstration, could be void
    },
    withdraw: function(amount) {
      if (amount <= balance) {
        balance -= amount;
        return balance; //Returning for demonstration, could be void
      } else {
        return "Insufficient funds.";
      }
    },
    getBalance: function() {
      return balance;
    }
  };
}

const account = createBankAccount(1000);

console.log(account.deposit(500)); // Output: 1500
console.log(account.withdraw(200)); // Output: 1300
console.log(account.getBalance()); // Output: 1300

// Trying to access balance directly will not work
// console.log(account.balance); // Output: undefined

വിശദീകരണം:

• createBankAccount() പണം നിക്ഷേപിക്കാനും പിൻവലിക്കാനും ബാലൻസ് അറിയാനുമുള്ള മെത്തേഡുകളുള്ള ഒരു ബാങ്ക് അക്കൗണ്ട് ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നു.
• balance എന്ന വേരിയബിൾ createBankAccount()-ൻ്റെ സ്കോപ്പിലാണ് പ്രഖ്യാപിച്ചിരിക്കുന്നത്, അത് പുറത്തുനിന്ന് നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയില്ല.
• deposit, withdraw, getBalance എന്നീ മെത്തേഡുകൾ balance എന്ന വേരിയബിളിന്മേൽ ക്ലോഷറുകൾ രൂപീകരിക്കുന്നു.
• ഈ മെത്തേഡുകൾക്ക് balance വേരിയബിളിനെ ആക്സസ് ചെയ്യാനും മാറ്റം വരുത്താനും കഴിയും, പക്ഷേ വേരിയബിൾ സ്വകാര്യമായി തുടരുന്നു.

ഉദാഹരണം 3: ലൂപ്പിൽ `setTimeout` உடன் ക്ലോഷറുകൾ ഉപയോഗിക്കുന്നത്

setTimeout പോലുള്ള അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ ചെയ്യുമ്പോൾ, പ്രത്യേകിച്ച് ലൂപ്പുകൾക്കുള്ളിൽ ക്ലോഷറുകൾ അത്യാവശ്യമാണ്. ക്ലോഷറുകൾ ഇല്ലെങ്കിൽ, ജാവാസ്ക്രിപ്റ്റിൻ്റെ അസിൻക്രണസ് സ്വഭാവം കാരണം നിങ്ങൾക്ക് അപ്രതീക്ഷിതമായ ഫലങ്ങൾ നേരിടേണ്ടി വരും.

for (var i = 1; i <= 5; i++) {
  (function(j) {
    setTimeout(function() {
      console.log("Value of i: " + j);
    }, j * 1000);
  })(i);
}

// Output:
// Value of i: 1 (after 1 second)
// Value of i: 2 (after 2 seconds)
// Value of i: 3 (after 3 seconds)
// Value of i: 4 (after 4 seconds)
// Value of i: 5 (after 5 seconds)

വിശദീകരണം:

• ക്ലോഷർ (ഉടനടി വിളിക്കുന്ന ഫംഗ്ഷൻ എക്സ്പ്രഷൻ അഥവാ IIFE) ഇല്ലായിരുന്നെങ്കിൽ, എല്ലാ setTimeout കോൾബാക്കുകളും ഒരേ i വേരിയബിളിനെയാവും റഫർ ചെയ്യുക, ലൂപ്പ് പൂർത്തിയായ ശേഷം അതിന് 6 എന്ന അന്തിമ മൂല്യം ഉണ്ടാകും.
• IIFE ലൂപ്പിൻ്റെ ഓരോ ആവർത്തനത്തിനും ഒരു പുതിയ സ്കോപ്പ് ഉണ്ടാക്കുകയും, i-യുടെ നിലവിലെ മൂല്യം j പാരാമീറ്ററിൽ പിടിച്ചെടുക്കുകയും ചെയ്യുന്നു.
• ഓരോ setTimeout കോൾബാക്കും j വേരിയബിളിന്മേൽ ഒരു ക്ലോഷർ രൂപീകരിക്കുന്നു, ഇത് ഓരോ ആവർത്തനത്തിനും i-യുടെ ശരിയായ മൂല്യം ലോഗ് ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

ലൂപ്പിൽ var-ന് പകരം let ഉപയോഗിക്കുന്നതും ഈ പ്രശ്നം പരിഹരിക്കും, കാരണം let ഓരോ ആവർത്തനത്തിനും ഒരു ബ്ലോക്ക് സ്കോപ്പ് സൃഷ്ടിക്കുന്നു.

for (let i = 1; i <= 5; i++) {
  setTimeout(function() {
    console.log("Value of i: " + i);
  }, i * 1000);
}

// Output (same as above):
// Value of i: 1 (after 1 second)
// Value of i: 2 (after 2 seconds)
// Value of i: 3 (after 3 seconds)
// Value of i: 4 (after 4 seconds)
// Value of i: 5 (after 5 seconds)

ഉദാഹരണം 4: കറിയിംഗും പാർഷ്യൽ ആപ്ലിക്കേഷനും

ഒന്നിലധികം ആർഗ്യുമെൻ്റുകളുള്ള ഫംഗ്ഷനുകളെ ഒരൊറ്റ ആർഗ്യുമെൻ്റ് എടുക്കുന്ന ഫംഗ്ഷനുകളുടെ ഒരു ശ്രേണിയാക്കി മാറ്റാൻ ഉപയോഗിക്കുന്ന കറിയിംഗ്, പാർഷ്യൽ ആപ്ലിക്കേഷൻ തുടങ്ങിയ ടെക്നിക്കുകൾക്ക് ക്ലോഷറുകൾ അടിസ്ഥാനമാണ്.

function multiply(a) {
  return function(b) {
    return function(c) {
      return a * b * c;
    };
  };
}

const multiplyBy5 = multiply(5);
const multiplyBy5And2 = multiplyBy5(2);

console.log(multiplyBy5And2(3)); // Output: 30 (5 * 2 * 3)

വിശദീകരണം:

• multiply എന്നത് മൂന്ന് ആർഗ്യുമെൻ്റുകൾ ഒരേ സമയം ഒന്നായി എടുക്കുന്ന ഒരു കറിഡ് ഫംഗ്ഷനാണ്.
• ഓരോ ആന്തരിക ഫംഗ്ഷനും അതിൻ്റെ പുറമെയുള്ള സ്കോപ്പിൽ നിന്നുള്ള വേരിയബിളുകളിൽ (a, b) ഒരു ക്ലോഷർ രൂപീകരിക്കുന്നു.
• multiplyBy5 എന്നത് a യുടെ മൂല്യം 5 ആയി ഇതിനകം സജ്ജീകരിച്ച ഒരു ഫംഗ്ഷനാണ്.
• multiplyBy5And2 എന്നത് a യുടെ മൂല്യം 5 ആയും b യുടെ മൂല്യം 2 ആയും ഇതിനകം സജ്ജീകരിച്ച ഒരു ഫംഗ്ഷനാണ്.
• multiplyBy5And2(3) എന്ന അവസാന കോൾ കണക്കുകൂട്ടൽ പൂർത്തിയാക്കി ഫലം നൽകുന്നു.

ഉദാഹരണം 5: മൊഡ്യൂൾ പാറ്റേൺ

മൊഡ്യൂൾ പാറ്റേണിൽ ക്ലോഷറുകൾ ധാരാളമായി ഉപയോഗിക്കുന്നു, ഇത് ജാവാസ്ക്രിപ്റ്റ് കോഡ് ഓർഗനൈസുചെയ്യാനും ഘടനാപരമാക്കാനും സഹായിക്കുന്നു, ഇത് മോഡുലാരിറ്റി പ്രോത്സാഹിപ്പിക്കുകയും പേരിടൽ വൈരുദ്ധ്യങ്ങൾ തടയുകയും ചെയ്യുന്നു.

const myModule = (function() {
  let privateVariable = "Hello, world!";

  function privateMethod() {
    console.log(privateVariable);
  }

  return {
    publicMethod: function() {
      privateMethod();
    },
    publicProperty: "This is a public property."
  };
})();

console.log(myModule.publicProperty); // Output: This is a public property.
myModule.publicMethod(); // Output: Hello, world!

// Trying to access privateVariable or privateMethod directly will not work
// console.log(myModule.privateVariable); // Output: undefined
// myModule.privateMethod(); // Output: TypeError: myModule.privateMethod is not a function

വിശദീകരണം:

• IIFE ഒരു പുതിയ സ്കോപ്പ് ഉണ്ടാക്കുകയും, privateVariable, privateMethod എന്നിവയെ എൻക്യാപ്‌സുലേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു.
• തിരികെ ലഭിക്കുന്ന ഒബ്ജക്റ്റ് publicMethod, publicProperty എന്നിവയെ മാത്രം പുറത്ത് കാണിക്കുന്നു.
• publicMethod, privateMethod, privateVariable എന്നിവയിന്മേൽ ഒരു ക്ലോഷർ രൂപീകരിക്കുന്നു, IIFE പ്രവർത്തിച്ച ശേഷവും അവയെ ആക്സസ് ചെയ്യാൻ ഇത് അനുവദിക്കുന്നു.
• ഈ പാറ്റേൺ സ്വകാര്യവും പൊതുവുമായ അംഗങ്ങളുള്ള ഒരു മൊഡ്യൂൾ ഫലപ്രദമായി സൃഷ്ടിക്കുന്നു.

ക്ലോഷറുകളും മെമ്മറി മാനേജ്മെൻ്റും

ക്ലോഷറുകൾ ശക്തമാണെങ്കിലും, മെമ്മറി മാനേജ്മെൻ്റിൽ അവയുടെ സ്വാധീനത്തെക്കുറിച്ച് അറിഞ്ഞിരിക്കേണ്ടത് പ്രധാനമാണ്. ക്ലോഷറുകൾ അവയുടെ ചുറ്റുമുള്ള സ്കോപ്പിൽ നിന്നുള്ള വേരിയബിളുകളിലേക്ക് ആക്‌സസ് നിലനിർത്തുന്നതിനാൽ, ആ വേരിയബിളുകൾ ഇനി ആവശ്യമില്ലെങ്കിൽ ഗാർബേജ് കളക്ഷൻ വഴി നീക്കം ചെയ്യപ്പെടുന്നത് തടയാൻ അവയ്ക്ക് കഴിയും. ശ്രദ്ധയോടെ കൈകാര്യം ചെയ്തില്ലെങ്കിൽ ഇത് മെമ്മറി ലീക്കുകളിലേക്ക് നയിച്ചേക്കാം.

മെമ്മറി ലീക്കുകൾ ഒഴിവാക്കാൻ, ക്ലോഷറുകൾക്കുള്ളിലെ വേരിയബിളുകൾക്ക് ഇനി ആവശ്യമില്ലെങ്കിൽ അവയിലേക്കുള്ള അനാവശ്യ റഫറൻസുകൾ ഒഴിവാക്കുക. വേരിയബിളുകൾ null ആക്കി സജ്ജീകരിക്കുന്നതിലൂടെയോ അല്ലെങ്കിൽ അനാവശ്യമായ ക്ലോഷറുകൾ സൃഷ്ടിക്കുന്നത് ഒഴിവാക്കുന്നതിനായി നിങ്ങളുടെ കോഡ് പുനഃക്രമീകരിക്കുന്നതിലൂടെയോ ഇത് ചെയ്യാവുന്നതാണ്.

ഒഴിവാക്കേണ്ട സാധാരണ ക്ലോഷർ തെറ്റുകൾ

• ലെക്സിക്കൽ സ്കോപ്പ് മറന്നുപോകുന്നത്: ഒരു ക്ലോഷർ അത് സൃഷ്ടിക്കപ്പെട്ട സമയത്തെ പരിസ്ഥിതിയാണ് പിടിച്ചെടുക്കുന്നത് എന്ന് എപ്പോഴും ഓർക്കുക. ക്ലോഷർ ഉണ്ടാക്കിയ ശേഷം വേരിയബിളുകൾ മാറിയാൽ, ക്ലോഷർ ആ മാറ്റങ്ങൾ പ്രതിഫലിപ്പിക്കും.
• അനാവശ്യ ക്ലോഷറുകൾ ഉണ്ടാക്കുന്നത്: ആവശ്യമില്ലെങ്കിൽ ക്ലോഷറുകൾ ഉണ്ടാക്കുന്നത് ഒഴിവാക്കുക, കാരണം അവ പ്രകടനത്തെയും മെമ്മറി ഉപയോഗത്തെയും ബാധിക്കും.
• വേരിയബിളുകൾ ലീക്ക് ആകുന്നത്: ക്ലോഷറുകളാൽ പിടിച്ചെടുക്കപ്പെട്ട വേരിയബിളുകളുടെ ആയുസ്സിനെക്കുറിച്ച് ശ്രദ്ധാലുവായിരിക്കുക, മെമ്മറി ലീക്കുകൾ തടയാൻ അവ ഇനി ആവശ്യമില്ലെങ്കിൽ റിലീസ് ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുക.

ഉപസംഹാരം

ഏതൊരു ജാവാസ്ക്രിപ്റ്റ് ഡെവലപ്പറും മനസ്സിലാക്കേണ്ട ശക്തവും അത്യാവശ്യവുമായ ഒരു ആശയമാണ് ജാവാസ്ക്രിപ്റ്റ് ക്ലോഷറുകൾ. അവ ഡാറ്റാ എൻക്യാപ്‌സുലേഷൻ, സ്റ്റേറ്റ് സംരക്ഷണം, ഹയർ-ഓർഡർ ഫംഗ്ഷനുകൾ, അസിൻക്രണസ് പ്രോഗ്രാമിംഗ് എന്നിവ സാധ്യമാക്കുന്നു. ക്ലോഷറുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും അവ എങ്ങനെ ഫലപ്രദമായി ഉപയോഗിക്കാമെന്നും മനസ്സിലാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് കൂടുതൽ കാര്യക്ഷമവും, പരിപാലിക്കാൻ എളുപ്പമുള്ളതും, സുരക്ഷിതവുമായ കോഡ് എഴുതാൻ കഴിയും.

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

കൂടുതൽ പഠിക്കാൻ

• മോസില്ല ഡെവലപ്പർ നെറ്റ്‌വർക്ക് (MDN): ക്ലോഷറുകൾ - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures
• You Don't Know JS: Scope & Closures - കൈൽ സിംപ്‌സൺ
• വിവിധ ക്ലോഷർ ഉദാഹരണങ്ങൾ പരീക്ഷിക്കാൻ CodePen, JSFiddle പോലുള്ള ഓൺലൈൻ കോഡിംഗ് പ്ലാറ്റ്‌ഫോമുകൾ പര്യവേക്ഷണം ചെയ്യുക.