Blog

JavaScript Closures Kya Hota Hai – What is JavaScript Closures

JavaScript Closures Kya Hota Hai ?

Definition:

JavaScript mein closure ek aisi concept hai jisme ek inner function apne outer function ke variables ko access kar sakta hai, chahe outer function execute hone ke baad bhi. Jab ek function doosre function ke andar define hota hai aur wo uske scope ke variables ko yaad rakhta hai, to usse closure kehte hain.

Yeh bahut useful hota hai jab hume data ko private rakhna ho ya kisi specific context mein variable ko preserve karna ho. JavaScript mein har baar jab ek function banta hai, uske sath ek lexical environment bhi banta hai.

Agar inner function, outer scope ke variable ko access karta hai, to wo closure ban jata hai. Jaise agar ek function counter banata hai jo ek private variable ko update karta hai bina directly access kiye, to wo closure ka example hai.

Closures powerful aur flexible coding ka ek important hissa hain.

Basic Example:

Yeh ek simple example hai jisse hum closure ko samajhte hain:

function outerFunction() {
  let outerVariable = 'I am from outer function'; // Outer function ka variable

  function innerFunction() {
    console.log(outerVariable); // Inner function, jo outer function ka variable access kar raha hai
  }

  return innerFunction; // Return kar rahe hain inner function ko
}

let closureExample = outerFunction();
closureExample(); // Output: 'I am from outer function'

How Closures Work:

Jab outerFunction execute hota hai, wo apni innerFunction ko return karta hai. Jab hum closureExample() call karte hain, to wo inner function execute hota hai, lekin fir bhi wo outerVariable ko access kar pata hai jo outerFunction ke scope mein tha.

Key Points About Closures:

  • Scope Chain: Closure ek scope chain ko maintain karta hai, matlab jab bhi ek closure execute hota hai, wo apne surrounding scopes ko yaad rakhta hai (lexical scoping). Iska matlab hai ki wo apne parent function ke variables ko access kar sakta hai, even after the parent function has finished executing.
  • Data Encapsulation: Closures ka use data ko encapsulate karne ke liye hota hai, jahan ek private variable sirf ek function ke through accessible hota hai.

Example:

function counter() {
  let count = 0; // Private variable

  return {
    increment: function() {
      count++;
      console.log(count);
    },
    decrement: function() {
      count--;
      console.log(count);
    }
  };
}

let myCounter = counter();
myCounter.increment(); // Output: 1
myCounter.increment(); // Output: 2
myCounter.decrement(); // Output: 1

Yahan count ek private variable hai jo directly access nahi ho sakta, but increment aur decrement functions ke through hum usse manipulate kar sakte hain. Yeh closure ka use hota hai jo ek secure environment banata hai.

Memory Management:

Closures memory ko efficiently use karte hain. Jab ek closure function banata hai, to uske saath associated variables memory mein persist rehte hain, jab tak wo closure kisi other function se call ho raha ho. Yeh memory leak ki wajah bhi ban sakta hai agar closures ko proper tarike se manage na kiya jaaye.

Lexical Scoping:

JavaScript mein lexical scoping ka concept hai, jo yeh batata hai ki kisi variable ki value kis scope mein available hogi. Jab hum closure banate hain, to wo lexical scope ka part hota hai, jo function ki original position ko yaad rakhta hai.

Closure Example with Loop:

Ek typical use case hai jab aap closure ko loop ke andar use karte hain.

function createFunctions() {
  let funcs = [];
  for (let i = 0; i < 3; i++) {
    funcs.push(function() {
      console.log(i); // i ko closure ke through access kar rahe hain
    });
  }
  return funcs;
}

let funcsArray = createFunctions();
funcsArray[0](); // Output: 3
funcsArray[1](); // Output: 3
funcsArray[2](); // Output: 3

Yahan par sabhi closures ko ek hi i variable ka access hai, jo loop ke end me 3 ho jata hai. Is case mein, closures loop ke last value ko yaad rakh rahe hain.

Common Use Cases of Closures:

  • Private Variables: Jab aapko kisi variable ko private rakhna ho, to closures ka use hota hai. Example ke liye, JavaScript classes mein private properties ko manage karte waqt closure ka use hota hai.
  • Callback Functions & Event Handlers: Jab aap callback functions ya event handlers likhte ho, closures automatically apne surrounding context ko retain karte hain.
  • Currying: Closures ko currying mein use kiya jata hai jahan ek function ko multiple arguments ke liye break kiya jata hai.

 Example:

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

let multiplyBy2 = multiply(2);
console.log(multiplyBy2(5)); // Output: 10

Important Points to Remember:

  • Closures ko samajhna thoda tricky ho sakta hai, lekin ek baar aapko iske working samajh mein aa jaye, to aapko JavaScript mein kaafi flexibility milegi.
  • Closures aapko powerful concepts jaise data encapsulation aur private state ko handle karne mein help karte hain.
  • Ye memory ko efficiently use karte hain, lekin agar closures ko properly manage na kiya jaye, to memory leaks ka issue aa sakta hai.

Conclusion:

Closures JavaScript ka ek ahem feature hai, jo functions ke behavior ko samajhne mein madad karta hai. Closures se aap apne code ko cleaner, modular aur secure bana sakte hain. Yeh advanced concept hai, lekin ek baar samajh jaane par yeh apke programming skills ko next level pe le jaata hai.

Quiz: Test Your Knowledge on JavaScript Closures

Bonus: Practical Application!

Aaj hi apne JavaScript code mein closures ka istemal karke dekhein!

JavaScript Closures ko sahi tareeke se samajhne ke liye different use-cases jaise function inside function, data encapsulation, aur lexical scope ka upayog karein. Isse aap apne code ko zyada secure, efficient aur modular bana sakte hain!

Leave a Reply