Closures

Introduction
Closures are one of the most important and powerful concepts in JavaScript. They allow a function to access variables from another function even after that outer function has finished executing. This helps in managing data, creating private variables, and writing more efficient code.

What is a Closure
A closure is created when a function remembers and can access its lexical scope even when it is executed outside that scope. In simple terms, a closure gives you access to an outer function’s variables from an inner function.

How Closures Work
When a function is defined inside another function, the inner function has access to the outer function’s variables. Even if the outer function finishes execution, the inner function keeps a reference to those variables.

Example

function outerFunction() {
  let count = 0;

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

  return innerFunction;
}

const counter = outerFunction();

counter();
counter();
counter();

In this example, the innerFunction remembers the variable count even after outerFunction has finished executing.

Key Concepts of Closures

Lexical Scope
Closures are based on lexical scope, meaning a function can access variables defined in its outer scope.

Data Persistence
Variables inside a closure are preserved in memory and can be reused.

Encapsulation
Closures allow you to create private variables that cannot be accessed directly from outside.

Practical Uses of Closures

Data Privacy
Closures help protect data by restricting direct access to variables.

Function Factories
You can create multiple functions with customized behavior.

Event Handlers
Closures are often used in callbacks and event listeners.

Memoization
Closures help store results of expensive function calls to improve performance.

Example of Data Privacy

function createBankAccount() {
  let balance = 0;

  return {
    deposit: function(amount) {
      balance += amount;
      console.log("Balance:", balance);
    },
    withdraw: function(amount) {
      balance -= amount;
      console.log("Balance:", balance);
    }
  };
}

const account = createBankAccount();
account.deposit(100);
account.withdraw(50);

Here, the balance variable is private and can only be accessed through the returned functions.

Advantages of Closures

Helps create private variables
Improves code organization
Supports functional programming
Reduces global variable usage

Common Mistakes

Using closures inside loops without proper scope handling
Holding unnecessary data in memory which may cause memory leaks
Overusing closures can make code harder to understand

Conclusion
Closures are a core concept in JavaScript that enable powerful programming techniques like data encapsulation and function reuse. Understanding closures will help you write cleaner, more efficient, and professional code.