M

MLOG

తెలుగు

ప్రాక్టికల్ ఉదాహరణల ద్వారా జావాస్క్రిప్ట్ క్లోజర్స్ గురించి తెలుసుకోండి, అవి ఎలా పనిచేస్తాయో మరియు సాఫ్ట్‌వేర్ డెవలప్‌మెంట్‌లో వాటి వాస్తవ-ప్రపంచ అనువర్తనాలను అర్థం చేసుకోండి.

జావాస్క్రిప్ట్ క్లోజర్స్: ప్రాక్టికల్ ఉదాహరణలతో వివరణ

జావాస్క్రిప్ట్‌లో క్లోజర్స్ ఒక ప్రాథమిక భావన, ఇది అన్ని స్థాయిల డెవలపర్‌లకు తరచుగా గందరగోళాన్ని కలిగిస్తుంది. సమర్థవంతమైన, నిర్వహించదగిన మరియు సురక్షితమైన కోడ్‌ను వ్రాయడానికి క్లోజర్‌లను అర్థం చేసుకోవడం చాలా ముఖ్యం. ఈ సమగ్ర గైడ్ ప్రాక్టికల్ ఉదాహరణలతో క్లోజర్‌లను వివరిస్తుంది మరియు వాటి వాస్తవ-ప్రపంచ అనువర్తనాలను ప్రదర్శిస్తుంది.

క్లోజర్ అంటే ఏమిటి?

సాధారణంగా చెప్పాలంటే, క్లోజర్ అనేది ఒక ఫంక్షన్ మరియు ఆ ఫంక్షన్ ప్రకటించబడిన లెక్సికల్ ఎన్విరాన్‌మెంట్ యొక్క కలయిక. అంటే, బయటి ఫంక్షన్ అమలు పూర్తయిన తర్వాత కూడా, దాని చుట్టూ ఉన్న స్కోప్ నుండి వేరియబుల్స్‌ను యాక్సెస్ చేయడానికి క్లోజర్ ఒక ఫంక్షన్‌ను అనుమతిస్తుంది. లోపలి ఫంక్షన్ తన పరిసరాలను "గుర్తుంచుకోవడం"గా దీనిని భావించండి.

దీనిని నిజంగా అర్థం చేసుకోవడానికి, ముఖ్య భాగాలను విశ్లేషిద్దాం:

ఇక్కడ మ్యాజిక్ ఏమిటంటే, బయటి ఫంక్షన్ తిరిగి వచ్చిన తర్వాత కూడా, లోపలి ఫంక్షన్ తన లెక్సికల్ స్కోప్‌లోని వేరియబుల్స్‌కు యాక్సెస్ కలిగి ఉంటుంది. జావాస్క్రిప్ట్ స్కోప్ మరియు మెమరీ మేనేజ్‌మెంట్‌ను నిర్వహించే విధానంలో ఈ ప్రవర్తన ఒక ముఖ్య భాగం.

క్లోజర్స్ ఎందుకు ముఖ్యమైనవి?

క్లోజర్స్ కేవలం ఒక సిద్ధాంతపరమైన భావన మాత్రమే కాదు; జావాస్క్రిప్ట్‌లోని అనేక సాధారణ ప్రోగ్రామింగ్ పద్ధతులకు ఇవి అవసరం. అవి ఈ క్రింది ప్రయోజనాలను అందిస్తాయి:

జావాస్క్రిప్ట్ క్లోజర్స్ యొక్క ప్రాక్టికల్ ఉదాహరణలు

క్లోజర్‌లు ఎలా పనిచేస్తాయో మరియు వాస్తవ-ప్రపంచ దృశ్యాలలో వాటిని ఎలా ఉపయోగించవచ్చో వివరించడానికి కొన్ని ప్రాక్టికల్ ఉదాహరణలను పరిశీలిద్దాం.

ఉదాహరణ 1: సాధారణ కౌంటర్

ఫంక్షన్ కాల్స్ మధ్య తన స్థితిని కొనసాగించే కౌంటర్‌ను సృష్టించడానికి క్లోజర్‌ను ఎలా ఉపయోగించవచ్చో ఈ ఉదాహరణ వివరిస్తుంది.


function createCounter() {
  let count = 0;

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

const increment = createCounter();

increment(); // అవుట్‌పుట్: 1
increment(); // అవుట్‌పుట్: 2
increment(); // అవుట్‌పుట్: 3

వివరణ:

ఉదాహరణ 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 "తగినంత నిధులు లేవు.";
      }
    },
    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

వివరణ:

ఉదాహరణ 3: లూప్‌లో `setTimeout`తో క్లోజర్‌లను ఉపయోగించడం

లూప్‌లలో ప్రత్యేకించి, `setTimeout` వంటి అసింక్రోనస్ ఆపరేషన్‌లతో పనిచేసేటప్పుడు క్లోజర్‌లు చాలా అవసరం. క్లోజర్‌లు లేకుండా, జావాస్క్రిప్ట్ యొక్క అసింక్రోనస్ స్వభావం కారణంగా మీరు అనుకోని ప్రవర్తనను ఎదుర్కోవచ్చు.


for (var i = 1; i <= 5; i++) {
  (function(j) {
    setTimeout(function() {
      console.log("i యొక్క విలువ: " + j);
    }, j * 1000);
  })(i);
}

// అవుట్‌పుట్:
// i యొక్క విలువ: 1 (1 సెకను తర్వాత)
// i యొక్క విలువ: 2 (2 సెకన్ల తర్వాత)
// i యొక్క విలువ: 3 (3 సెకన్ల తర్వాత)
// i యొక్క విలువ: 4 (4 సెకన్ల తర్వాత)
// i యొక్క విలువ: 5 (5 సెకన్ల తర్వాత)

వివరణ:

లూప్‌లో `var` కు బదులుగా `let` ఉపయోగించడం కూడా ఈ సమస్యను పరిష్కరిస్తుంది, ఎందుకంటే `let` ప్రతి పునరావృత్తికి ఒక బ్లాక్ స్కోప్‌ను సృష్టిస్తుంది.


for (let i = 1; i <= 5; i++) {
  setTimeout(function() {
    console.log("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)

వివరణ:

ఉదాహరణ 5: మాడ్యూల్ ప్యాటర్న్

జావాస్క్రిప్ట్ కోడ్‌ను నిర్వహించడానికి మరియు నిర్మాణానికి సహాయపడే మాడ్యూల్ ప్యాటర్న్‌లో క్లోజర్‌లు ఎక్కువగా ఉపయోగించబడతాయి, ఇది మాడ్యులారిటీని ప్రోత్సహిస్తుంది మరియు పేర్ల వైరుధ్యాలను నివారిస్తుంది.


const myModule = (function() {
  let privateVariable = "హలో, ప్రపంచం!";

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

  return {
    publicMethod: function() {
      privateMethod();
    },
    publicProperty: "ఇది ఒక పబ్లిక్ ప్రాపర్టీ."
  };
})();

console.log(myModule.publicProperty); // అవుట్‌పుట్: ఇది ఒక పబ్లిక్ ప్రాపర్టీ.
myModule.publicMethod(); // అవుట్‌పుట్: హలో, ప్రపంచం!

// privateVariable లేదా privateMethodను నేరుగా యాక్సెస్ చేయడానికి ప్రయత్నిస్తే పని చేయదు
// console.log(myModule.privateVariable); // అవుట్‌పుట్: undefined
// myModule.privateMethod(); // అవుట్‌పుట్: TypeError: myModule.privateMethod is not a function

వివరణ:

క్లోజర్స్ మరియు మెమరీ మేనేజ్‌మెంట్

క్లోజర్స్ శక్తివంతమైనవి అయినప్పటికీ, మెమరీ మేనేజ్‌మెంట్‌పై వాటి సంభావ్య ప్రభావాన్ని గురించి తెలుసుకోవడం ముఖ్యం. క్లోజర్స్ తమ చుట్టూ ఉన్న స్కోప్ నుండి వేరియబుల్స్‌కు యాక్సెస్ కలిగి ఉన్నందున, ఆ వేరియబుల్స్ ఇకపై అవసరం లేకపోయినా, అవి గార్బేజ్ కలెక్ట్ చేయబడకుండా నిరోధించగలవు. ఇది జాగ్రత్తగా నిర్వహించకపోతే మెమరీ లీక్‌లకు దారితీయవచ్చు.

మెమరీ లీక్‌లను నివారించడానికి, క్లోజర్‌లలోని వేరియబుల్స్‌కు ఇకపై అవసరం లేనప్పుడు అనవసరమైన రిఫరెన్స్‌లను విచ్ఛిన్నం చేయాలని నిర్ధారించుకోండి. ఇది వేరియబుల్స్‌ను `null` కు సెట్ చేయడం ద్వారా లేదా అనవసరమైన క్లోజర్‌లను సృష్టించకుండా మీ కోడ్‌ను పునర్నిర్మించడం ద్వారా చేయవచ్చు.

క్లోజర్స్‌లో నివారించాల్సిన సాధారణ తప్పులు

ముగింపు

ఏ జావాస్క్రిప్ట్ డెవలపర్‌కైనా జావాస్క్రిప్ట్ క్లోజర్స్ అనేది ఒక శక్తివంతమైన మరియు అవసరమైన భావన. అవి డేటా ఎన్‌క్యాప్సులేషన్, స్థితిని భద్రపరచడం, ఉన్నత-స్థాయి ఫంక్షన్స్ మరియు అసింక్రోనస్ ప్రోగ్రామింగ్‌ను సాధ్యం చేస్తాయి. క్లోజర్‌లు ఎలా పనిచేస్తాయో మరియు వాటిని ప్రభావవంతంగా ఎలా ఉపయోగించాలో అర్థం చేసుకోవడం ద్వారా, మీరు మరింత సమర్థవంతమైన, నిర్వహించదగిన మరియు సురక్షితమైన కోడ్‌ను వ్రాయగలరు.

ఈ గైడ్ ప్రాక్టికల్ ఉదాహరణలతో క్లోజర్‌ల యొక్క సమగ్ర అవలోకనాన్ని అందించింది. ఈ ఉదాహరణలతో ప్రాక్టీస్ చేయడం మరియు ప్రయోగాలు చేయడం ద్వారా, మీరు క్లోజర్‌లపై మీ అవగాహనను పెంచుకోవచ్చు మరియు మరింత నిపుణులైన జావాస్క్రిప్ట్ డెవలపర్‌గా మారవచ్చు.

మరింత తెలుసుకోండి