JavaScript Closures

JavaScript Closures అంటే ఏమిటి?

Closure అనేది ఒక function తనకు బయట ఉన్న scope లోని variables ను గుర్తుంచుకుని, ఆ scope ముగిసిన తర్వాత కూడా వాటిని ఉపయోగించగలగడం.

ఒక inner function ను outer function లో create చేసినప్పుడు, inner function కు outer function variables పై access ఉంటుంది. Outer function execution పూర్తయిన తర్వాత కూడా inner function ఆ variables ను preserve చేస్తుంది.

Closure ఎలా పనిచేస్తుంది?

ఒక outer function లో variable create చేస్తాము.
ఆ outer function లో ఒక inner function ను return చేస్తాము.
Inner function, outer variable ను access చేస్తుంది.
Outer function పూర్తయిన తర్వాత కూడా returned inner function ఆ variable value ను గుర్తుంచుకుంటుంది.

Closure ఉపయోగాలు

Private data create చేయడానికి
Counter functions తయారు చేయడానికి
Function factories రూపొందించడానికి
State ను preserve చేయడానికి

Closure లో variable ను నేరుగా బయట నుండి access చేయలేము. కానీ inner function ద్వారా ఆ variable ను update లేదా read చేయవచ్చు. ఈ విధంగా data ను protect చేయవచ్చు.

Simple Explanation

Closure ను ఒక చిన్న box లాగా ఊహించండి. Outer function లోని variable ఆ box లో ఉంటుంది. Outer function ముగిసిన తర్వాత కూడా inner function ఆ box ను తనతో పాటు తీసుకెళ్తుంది. అందువల్ల inner function ఆ variable ను మళ్లీ ఉపయోగించగలదు.

ఉదాహరణకు, counter function మొదట zero తో ప్రారంభమవుతుంది. ప్రతి సారి returned function ను call చేసినప్పుడు count పెరుగుతుంది. ఆ count value ప్రతి call మధ్యలో గుర్తుండటానికి కారణం closure.

Real-Life Example

ఒక wallet app లో balance ను నేరుగా బయట code మార్చకుండా ఉంచాలని అనుకుందాం. Outer function లో balance variable ఉంటుంది. Deposit మరియు withdraw functions మాత్రమే balance ను మార్చగలిగితే, balance private data లాగా పనిచేస్తుంది. ఇది closure కు real-life example.

Code Examples

Counter తో Closure

function createCounter() {
  let count = 0;

  return function () {
    count++;
    return count;
  };
}

const counter = createCounter();
console.log(counter());
console.log(counter());
console.log(counter());

createCounter function లో count అనే local variable ఉంది. ఈ function ఒక inner function ను return చేస్తుంది. Inner function ప్రతి call లో count ను పెంచుతుంది.

counter లో returned function store అవుతుంది. createCounter execution పూర్తయిన తర్వాత కూడా count variable గుర్తుండటం closure వల్ల జరుగుతుంది.

1
2
3

Private Balance తో Closure

function createWallet(initialBalance) {
  let balance = initialBalance;

  return {
    deposit: function (amount) {
      balance += amount;
    },
    getBalance: function () {
      return balance;
    }
  };
}

const wallet = createWallet(100);
wallet.deposit(50);
console.log(wallet.getBalance());

balance variable outer function లో ఉంది. బయట నుండి wallet.balance అని నేరుగా access చేయలేము. కానీ returned object లోని deposit మరియు getBalance functions closure ద్వారా balance ను access చేస్తాయి.

ఈ pattern ద్వారా data ను private గా ఉంచి, అవసరమైన functions ద్వారా మాత్రమే ఉపయోగించవచ్చు.

Line-by-Line Explanation

function createCounter() {

ఇది createCounter అనే outer function ను ప్రారంభిస్తుంది. ఈ function ఒక closure ను create చేయడానికి ఉపయోగపడుతుంది.

let count = 0;

ఇక్కడ count అనే local variable ను zero తో create చేస్తున్నాము. ఈ variable outer function scope లో ఉంటుంది.

return function () {

ఇక్కడ ఒక anonymous inner function ను return చేస్తున్నాము. ఈ inner function కు count variable పై access ఉంటుంది.

count++;

ప్రతి సారి inner function call అయినప్పుడు count value ఒకటి పెరుగుతుంది.

return count;

పెరిగిన count value ను inner function తిరిగి ఇస్తుంది.

};

ఇది inner function definition ను ముగిస్తుంది.

}

ఇది createCounter outer function ను ముగిస్తుంది. అయినప్పటికీ returned inner function కు count variable గుర్తుండిపోతుంది.

const counter = createCounter();

createCounter ను call చేసి, అది return చేసిన inner function ను counter constant లో store చేస్తున్నాము.

console.log(counter());

counter function మొదటిసారి call అవుతుంది. count value zero నుండి ఒకటిగా మారి console లో 1 చూపిస్తుంది.

console.log(counter());

counter function రెండవసారి call అవుతుంది. Closure count value ను గుర్తుంచుకున్నందువల్ల అది 2 అవుతుంది.

console.log(counter());

మూడవ call సమయంలో count value 3 అవుతుంది. ప్రతి call మధ్య value preserve కావడం closure behavior.

Try It

Try this JavaScript code:

Example

function createCounter() {
  let count = 0;

  return function () {
    // count ను పెంచి return చేయండి
  };
}

const counter = createCounter();
console.log(counter());
console.log(counter());

Try It Yourself »

Practice

Practice:

createMultiplier అనే function ను పూర్తి చేయండి. అది multiplier value ను closure లో గుర్తుంచుకుని, ఇచ్చిన number తో multiply చేసిన result ను return చేయాలి. double(5) ద్వారా 10 మరియు triple(7) ద్వారా 21 రావాలి.

Hint:

Returned inner function లో outer function యొక్క multiplier variable అందుబాటులో ఉంటుంది. దాన్ని number తో multiply చేసి return చేయండి.

Common Mistakes

Closure అంటే ప్రతి function అని అనుకోవడం.

ప్రతి function closure కాదు. సాధారణంగా ఒక inner function, తన outer scope variables ను గుర్తుంచుకుని ఉపయోగించినప్పుడు closure ఏర్పడుతుంది.

Outer function ముగిసిన వెంటనే దాని local variables పూర్తిగా నశిస్తాయని అనుకోవడం.

ఆ variable ను inner function ఉపయోగిస్తుంటే, JavaScript దానికి అవసరమైన environment ను preserve చేస్తుంది.

Closure లోని private variable ను బయట నుండి నేరుగా access చేయడానికి ప్రయత్నించడం.

Private variable ను access చేయడానికి closure return చేసిన getter లేదా updater functions ను ఉపయోగించాలి.

ప్రతి call లో variable మళ్లీ reset అవుతుందని అనుకోవడం.

ఒకే returned closure ను మళ్లీ మళ్లీ call చేస్తే, అది preserve చేసిన variable value ఆధారంగా కొనసాగుతుంది.

Interview Questions

JavaScript closure అంటే ఏమిటి?

Answer:

Closure అనేది ఒక function తన outer lexical scope లోని variables ను గుర్తుంచుకుని, outer function execution పూర్తయిన తర్వాత కూడా వాటిని ఉపయోగించగలగడం.

Closures ను ఎందుకు ఉపయోగిస్తారు?

Answer:

Closures ను private data, counters, function factories మరియు state preservation కోసం ఉపయోగిస్తారు.

Closure ద్వారా data ను ఎలా private గా ఉంచవచ్చు?

Answer:

Data ను outer function లోని local variable గా ఉంచి, దాన్ని access చేసే inner functions ను మాత్రమే return చేయాలి. బయట code కు local variable పై direct access ఉండదు.

ఒక counter closure లో value ఎందుకు reset కాదు?

Answer:

Returned inner function outer scope లోని count variable ను reference చేస్తుంది. అందువల్ల ప్రతి call మధ్య count value preserve అవుతుంది.

Exam Questions

Closure ఏర్పడటానికి అవసరమైన ముఖ్యమైన రెండు functions ఏవి?

Answer:

ఒక outer function మరియు దాని scope లో create చేయబడిన inner function అవసరం. Inner function outer function variable ను ఉపయోగించినప్పుడు closure behavior కనిపిస్తుంది.

క్రింది code లో ప్రతి call యొక్క output ఏమిటి: const add = createAdder(10); console.log(add(5));, ఇక్కడ createAdder multiplier లేదా base value ను closure లో గుర్తుంచుకుంటుంది.

Answer:

createAdder యొక్క implementation పై ఆధారపడి output మారుతుంది. అది base value ను number కు add చేసే closure అయితే output 15 అవుతుంది.

Closure మరియు global variable మధ్య ఒక ముఖ్యమైన తేడా ఏమిటి?

Answer:

Global variable ను program లోని అనేక ప్రాంతాల నుండి access చేయవచ్చు. Closure లోని variable outer function మరియు దాని returned inner functions ద్వారా నియంత్రించబడుతుంది, కాబట్టి data encapsulation మెరుగ్గా ఉంటుంది.

Quick Revision

Closure అనేది outer scope variables ను గుర్తుంచుకునే function.
Inner function కు outer function variables పై access ఉంటుంది.
Outer function పూర్తయిన తర్వాత కూడా closure variables preserve అవుతాయి.
Closures counters మరియు private data కోసం ఉపయోగపడతాయి.
ఒకే closure ను మళ్లీ మళ్లీ call చేస్తే state preserve అవుతుంది.
Private variable ను సాధారణంగా getter లేదా updater inner functions ద్వారా access చేస్తారు.

JavaScript Closures