ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕ್ಲೋಷರ್‌ಗಳು: ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ನಿಗೂಢತೆಯನ್ನು ಭೇದಿಸುವುದು

ಕ್ಲೋಷರ್‌ಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಒಂದು ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಯಾಗಿದ್ದು, ಇದು ಎಲ್ಲಾ ಹಂತದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಗೊಂದಲವನ್ನುಂಟುಮಾಡುತ್ತದೆ. ದಕ್ಷ, ನಿರ್ವಹಿಸಬಲ್ಲ, ಮತ್ತು ಸುರಕ್ಷಿತ ಕೋಡ್ ಬರೆಯಲು ಕ್ಲೋಷರ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಕ್ಲೋಷರ್‌ಗಳನ್ನು ನಿಗೂಢತೆಯಿಂದ ಹೊರತಂದು ಅವುಗಳ ನೈಜ-ಪ್ರಪಂಚದ ಅನ್ವಯಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಕ್ಲೋಷರ್ ಎಂದರೇನು?

ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಕ್ಲೋಷರ್ ಎಂದರೆ ಒಂದು ಫಂಕ್ಷನ್ ಮತ್ತು ಆ ಫಂಕ್ಷನ್ ಅನ್ನು ಘೋಷಿಸಿದ ಲೆಕ್ಸಿಕಲ್ ಪರಿಸರದ ಸಂಯೋಜನೆಯಾಗಿದೆ. ಇದರರ್ಥ, ಹೊರಗಿನ ಫಂಕ್ಷನ್ ಕಾರ್ಯಗತಗೊಂಡು ಮುಗಿದ ನಂತರವೂ, ಒಂದು ಕ್ಲೋಷರ್ ತನ್ನ ಸುತ್ತಮುತ್ತಲಿನ ಸ್ಕೋಪ್‌ನಿಂದ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಫಂಕ್ಷನ್‌ಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದನ್ನು ಒಳಗಿನ ಫಂಕ್ಷನ್ ತನ್ನ ಪರಿಸರವನ್ನು "ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳುವುದು" ಎಂದು ಭಾವಿಸಬಹುದು.

ಇದನ್ನು ನಿಜವಾಗಿಯೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಪ್ರಮುಖ ಅಂಶಗಳನ್ನು ವಿಭಜಿಸೋಣ:

• ಫಂಕ್ಷನ್: ಕ್ಲೋಷರ್‌ನ ಭಾಗವಾಗಿರುವ ಒಳಗಿನ ಫಂಕ್ಷನ್.
• ಲೆಕ್ಸಿಕಲ್ ಪರಿಸರ: ಫಂಕ್ಷನ್ ಅನ್ನು ಘೋಷಿಸಿದ ಸುತ್ತಮುತ್ತಲಿನ ಸ್ಕೋಪ್. ಇದರಲ್ಲಿ ವೇರಿಯಬಲ್‌ಗಳು, ಫಂಕ್ಷನ್‌ಗಳು ಮತ್ತು ಇತರ ಘೋಷಣೆಗಳು ಸೇರಿವೆ.

ಹೊರಗಿನ ಫಂಕ್ಷನ್ ಹಿಂತಿರುಗಿದ ನಂತರವೂ ಒಳಗಿನ ಫಂಕ್ಷನ್ ತನ್ನ ಲೆಕ್ಸಿಕಲ್ ಸ್ಕೋಪ್‌ನಲ್ಲಿರುವ ವೇರಿಯಬಲ್‌ಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಉಳಿಸಿಕೊಳ್ಳುವುದರಿಂದ ಈ ಮ್ಯಾಜಿಕ್ ನಡೆಯುತ್ತದೆ. ಈ ವರ್ತನೆಯು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಕೋಪ್ ಮತ್ತು ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸುತ್ತದೆ ಎಂಬುದರ ಪ್ರಮುಖ ಭಾಗವಾಗಿದೆ.

ಕ್ಲೋಷರ್‌ಗಳು ಏಕೆ ಮುಖ್ಯ?

ಕ್ಲೋಷರ್‌ಗಳು ಕೇವಲ ಒಂದು ಸೈದ್ಧಾಂತಿಕ ಪರಿಕಲ್ಪನೆಯಲ್ಲ; ಅವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಅನೇಕ ಸಾಮಾನ್ಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಗಳಿಗೆ ಅತ್ಯಗತ್ಯ. ಅವು ಈ ಕೆಳಗಿನ ಪ್ರಯೋಜನಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ:

• ಡೇಟಾ ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್: ಕ್ಲೋಷರ್‌ಗಳು ಖಾಸಗಿ ವೇರಿಯಬಲ್‌ಗಳು ಮತ್ತು ಮೆಥಡ್‌ಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ, ಡೇಟಾವನ್ನು ಹೊರಗಿನ ಪ್ರವೇಶ ಮತ್ತು ಮಾರ್ಪಾಡುಗಳಿಂದ ರಕ್ಷಿಸುತ್ತವೆ.
• ಸ್ಥಿತಿ ಸಂರಕ್ಷಣೆ: ಕ್ಲೋಷರ್‌ಗಳು ಫಂಕ್ಷನ್ ಕರೆಗಳ ನಡುವೆ ವೇರಿಯಬಲ್‌ಗಳ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ, ಇದು ಕೌಂಟರ್‌ಗಳು, ಟೈಮರ್‌ಗಳು ಮತ್ತು ಇತರ ಸ್ಥಿತಿಯುಳ್ಳ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಉಪಯುಕ್ತವಾಗಿದೆ.
• ಹೈಯರ್-ಆರ್ಡರ್ ಫಂಕ್ಷನ್‌ಗಳು: ಕ್ಲೋಷರ್‌ಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಹೈಯರ್-ಆರ್ಡರ್ ಫಂಕ್ಷನ್‌ಗಳೊಂದಿಗೆ (ಇತರ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವ ಅಥವಾ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್‌ಗಳು) ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಶಕ್ತಿಯುತ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಕೋಡ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
• ಅಸಿಂಕ್ರೋನಸ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್: ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳು ಮತ್ತು ಪ್ರಾಮಿಸ್‌ಗಳಂತಹ ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಕ್ಲೋಷರ್‌ಗಳು ನಿರ್ಣಾಯಕ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತವೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕ್ಲೋಷರ್‌ಗಳ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

ಕ್ಲೋಷರ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಮತ್ತು ಅವುಗಳನ್ನು ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ವಿವರಿಸಲು ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ.

ಉದಾಹರಣೆ 1: ಸರಳ ಕೌಂಟರ್

ಈ ಉದಾಹರಣೆಯು ಫಂಕ್ಷನ್ ಕರೆಗಳ ನಡುವೆ ತನ್ನ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸುವ ಕೌಂಟರ್ ಅನ್ನು ರಚಿಸಲು ಕ್ಲೋಷರ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

function createCounter() {
  let count = 0;

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

const increment = createCounter();

increment(); // ಔಟ್‌ಪುಟ್: 1
increment(); // ಔಟ್‌ಪುಟ್: 2
increment(); // ಔಟ್‌ಪುಟ್: 3

ವಿವರಣೆ:

• createCounter() ಒಂದು ಹೊರಗಿನ ಫಂಕ್ಷನ್ ಆಗಿದ್ದು, ಇದು count ಎಂಬ ವೇರಿಯಬಲ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ.
• ಇದು count ಅನ್ನು ಹೆಚ್ಚಿಸಿ ಅದರ ಮೌಲ್ಯವನ್ನು ಲಾಗ್ ಮಾಡುವ ಒಳಗಿನ ಫಂಕ್ಷನ್ ಅನ್ನು (ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅನಾಮಧೇಯ ಫಂಕ್ಷನ್) ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• ಒಳಗಿನ ಫಂಕ್ಷನ್ count ವೇರಿಯಬಲ್ ಮೇಲೆ ಕ್ಲೋಷರ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ.
• createCounter() ಕಾರ್ಯಗತಗೊಂಡು ಮುಗಿದ ನಂತರವೂ, ಒಳಗಿನ ಫಂಕ್ಷನ್ count ವೇರಿಯಬಲ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ.
• increment() ಗೆ ಪ್ರತಿ ಕರೆಯು ಅದೇ count ವೇರಿಯಬಲ್ ಅನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಇದು ಸ್ಥಿತಿಯನ್ನು ಸಂರಕ್ಷಿಸುವ ಕ್ಲೋಷರ್‌ನ ಸಾಮರ್ಥ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ 2: ಖಾಸಗಿ ವೇರಿಯಬಲ್‌ಗಳೊಂದಿಗೆ ಡೇಟಾ ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್

ಖಾಸಗಿ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ರಚಿಸಲು ಕ್ಲೋಷರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು, ಡೇಟಾವನ್ನು ಫಂಕ್ಷನ್‌ನ ಹೊರಗಿನಿಂದ ನೇರ ಪ್ರವೇಶ ಮತ್ತು ಮಾರ್ಪಾಡುಗಳಿಂದ ರಕ್ಷಿಸುತ್ತದೆ.

function createBankAccount(initialBalance) {
  let balance = initialBalance;

  return {
    deposit: function(amount) {
      balance += amount;
      return balance; // ಪ್ರದರ್ಶನಕ್ಕಾಗಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತಿದೆ, ವಾಯ್ಡ್ ಆಗಿರಬಹುದು
    },
    withdraw: function(amount) {
      if (amount <= balance) {
        balance -= amount;
        return balance; // ಪ್ರದರ್ಶನಕ್ಕಾಗಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತಿದೆ, ವಾಯ್ಡ್ ಆಗಿರಬಹುದು
      } else {
        return "Insufficient funds.";
      }
    },
    getBalance: function() {
      return balance;
    }
  };
}

const account = createBankAccount(1000);

console.log(account.deposit(500)); // ಔಟ್‌ಪುಟ್: 1500
console.log(account.withdraw(200)); // ಔಟ್‌ಪುಟ್: 1300
console.log(account.getBalance()); // ಔಟ್‌ಪುಟ್: 1300

// ಬ್ಯಾಲೆನ್ಸ್ ಅನ್ನು ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ
// console.log(account.balance); // ಔಟ್‌ಪುಟ್: 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);
}

// ಔಟ್‌ಪುಟ್:
// i ನ ಮೌಲ್ಯ: 1 (1 ಸೆಕೆಂಡಿನ ನಂತರ)
// i ನ ಮೌಲ್ಯ: 2 (2 ಸೆಕೆಂಡುಗಳ ನಂತರ)
// i ನ ಮೌಲ್ಯ: 3 (3 ಸೆಕೆಂಡುಗಳ ನಂತರ)
// i ನ ಮೌಲ್ಯ: 4 (4 ಸೆಕೆಂಡುಗಳ ನಂತರ)
// i ನ ಮೌಲ್ಯ: 5 (5 ಸೆಕೆಂಡುಗಳ ನಂತರ)

ವಿವರಣೆ:

• ಕ್ಲೋಷರ್ ಇಲ್ಲದೆ (ತಕ್ಷಣವೇ ಆಹ್ವಾನಿಸಲಾದ ಫಂಕ್ಷನ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಅಥವಾ 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);
}

// ಔಟ್‌ಪುಟ್ (ಮೇಲಿನಂತೆಯೇ):
// i ನ ಮೌಲ್ಯ: 1 (1 ಸೆಕೆಂಡಿನ ನಂತರ)
// i ನ ಮೌಲ್ಯ: 2 (2 ಸೆಕೆಂಡುಗಳ ನಂತರ)
// i ನ ಮೌಲ್ಯ: 3 (3 ಸೆಕೆಂಡುಗಳ ನಂತರ)
// i ನ ಮೌಲ್ಯ: 4 (4 ಸೆಕೆಂಡುಗಳ ನಂತರ)
// i ನ ಮೌಲ್ಯ: 5 (5 ಸೆಕೆಂಡುಗಳ ನಂತರ)

ಉದಾಹರಣೆ 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)); // ಔಟ್‌ಪುಟ್: 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); // ಔಟ್‌ಪುಟ್: This is a public property.
myModule.publicMethod(); // ಔಟ್‌ಪುಟ್: Hello, world!

// privateVariable ಅಥವಾ privateMethod ಅನ್ನು ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ
// console.log(myModule.privateVariable); // ಔಟ್‌ಪುಟ್: undefined
// myModule.privateMethod(); // ಔಟ್‌ಪುಟ್: TypeError: myModule.privateMethod is not a function

ವಿವರಣೆ:

• IIFE privateVariable ಮತ್ತು privateMethod ಅನ್ನು ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಟ್ ಮಾಡುವ ಮೂಲಕ ಹೊಸ ಸ್ಕೋಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
• ಹಿಂತಿರುಗಿದ ಆಬ್ಜೆಕ್ಟ್ ಕೇವಲ publicMethod ಮತ್ತು publicProperty ಅನ್ನು ಮಾತ್ರ ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ.
• publicMethod, privateMethod ಮತ್ತು privateVariable ಮೇಲೆ ಕ್ಲೋಷರ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ, IIFE ಕಾರ್ಯಗತಗೊಂಡ ನಂತರವೂ ಅವುಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
• ಈ ಪ್ಯಾಟರ್ನ್ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಖಾಸಗಿ ಮತ್ತು ಸಾರ್ವಜನಿಕ ಸದಸ್ಯರೊಂದಿಗೆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

ಕ್ಲೋಷರ್‌ಗಳು ಮತ್ತು ಮೆಮೊರಿ ನಿರ್ವಹಣೆ

ಕ್ಲೋಷರ್‌ಗಳು ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯ ಮೇಲೆ ಅವುಗಳ ಸಂಭಾವ್ಯ ಪ್ರಭಾವದ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದು ಮುಖ್ಯ. ಕ್ಲೋಷರ್‌ಗಳು ತಮ್ಮ ಸುತ್ತಮುತ್ತಲಿನ ಸ್ಕೋಪ್‌ನಿಂದ ವೇರಿಯಬಲ್‌ಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಉಳಿಸಿಕೊಳ್ಳುವುದರಿಂದ, ಅವುಗಳು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೂ ಆ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಟ್ ಮಾಡುವುದನ್ನು ತಡೆಯಬಹುದು. ಇದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸದಿದ್ದರೆ ಇದು ಮೆಮೊರಿ ಸೋರಿಕೆಗೆ ಕಾರಣವಾಗಬಹುದು.

ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ತಪ್ಪಿಸಲು, ಕ್ಲೋಷರ್‌ಗಳೊಳಗಿನ ವೇರಿಯಬಲ್‌ಗಳಿಗೆ ಅನಗತ್ಯ ಉಲ್ಲೇಖಗಳು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಅವುಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ವೇರಿಯಬಲ್‌ಗಳನ್ನು null ಗೆ ಹೊಂದಿಸುವ ಮೂಲಕ ಅಥವಾ ಅನಗತ್ಯ ಕ್ಲೋಷರ್‌ಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪುನರ್ರಚಿಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಬಹುದು.

ತಪ್ಪಿಸಬೇಕಾದ ಸಾಮಾನ್ಯ ಕ್ಲೋಷರ್ ತಪ್ಪುಗಳು

• ಲೆಕ್ಸಿಕಲ್ ಸ್ಕೋಪ್ ಅನ್ನು ಮರೆಯುವುದು: ಕ್ಲೋಷರ್ ತನ್ನ ರಚನೆಯ ಸಮಯದಲ್ಲಿ ಪರಿಸರವನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತದೆ ಎಂಬುದನ್ನು ಯಾವಾಗಲೂ ನೆನಪಿಡಿ. ಕ್ಲೋಷರ್ ಅನ್ನು ರಚಿಸಿದ ನಂತರ ವೇರಿಯಬಲ್‌ಗಳು ಬದಲಾದರೆ, ಕ್ಲೋಷರ್ ಆ ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ.
• ಅನಗತ್ಯ ಕ್ಲೋಷರ್‌ಗಳನ್ನು ರಚಿಸುವುದು: ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ ಕ್ಲೋಷರ್‌ಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ, ಏಕೆಂದರೆ ಅವು ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಮೆಮೊರಿ ಬಳಕೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು.
• ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಸೋರಿಕೆ ಮಾಡುವುದು: ಕ್ಲೋಷರ್‌ಗಳಿಂದ ಸೆರೆಹಿಡಿಯಲಾದ ವೇರಿಯಬಲ್‌ಗಳ ಜೀವಿತಾವಧಿಯ ಬಗ್ಗೆ ಗಮನವಿರಲಿ ಮತ್ತು ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ತಡೆಗಟ್ಟಲು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಅವುಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ತೀರ್ಮಾನ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕ್ಲೋಷರ್‌ಗಳು ಯಾವುದೇ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಾದ ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ಅತ್ಯಗತ್ಯ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ. ಅವು ಡೇಟಾ ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್, ಸ್ಥಿತಿ ಸಂರಕ್ಷಣೆ, ಹೈಯರ್-ಆರ್ಡರ್ ಫಂಕ್ಷನ್‌ಗಳು ಮತ್ತು ಅಸಿಂಕ್ರೋನಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತವೆ. ಕ್ಲೋಷರ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಮತ್ತು ಅವುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ದಕ್ಷ, ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ಸುರಕ್ಷಿತ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬಹುದು.

ಈ ಮಾರ್ಗದರ್ಶಿ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಕ್ಲೋಷರ್‌ಗಳ ಸಮಗ್ರ ಅವಲೋಕನವನ್ನು ಒದಗಿಸಿದೆ. ಈ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಅಭ್ಯಾಸ ಮತ್ತು ಪ್ರಯೋಗ ಮಾಡುವ ಮೂಲಕ, ನೀವು ಕ್ಲೋಷರ್‌ಗಳ ಬಗ್ಗೆ ನಿಮ್ಮ ತಿಳುವಳಿಕೆಯನ್ನು ಇನ್ನಷ್ಟು ಆಳವಾಗಿಸಬಹುದು ಮತ್ತು ಹೆಚ್ಚು ಪ್ರವೀಣ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್ ಆಗಬಹುದು.

ಹೆಚ್ಚಿನ ಕಲಿಕೆ

• Mozilla Developer Network (MDN): ಕ್ಲೋಷರ್‌ಗಳು - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures
• You Don't Know JS: Scope & Closures, ಕೈಲ್ ಸಿಂಪ್ಸನ್ ಅವರಿಂದ
• ವಿವಿಧ ಕ್ಲೋಷರ್ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಲು CodePen ಮತ್ತು JSFiddle ನಂತಹ ಆನ್‌ಲೈನ್ ಕೋಡಿಂಗ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸಿ.