Javascript Closures

Play this article

Introduction:

Closures are one of the most powerful and fundamental concepts in JavaScript, yet they can also be one of the most difficult to understand for beginners. In essence, closures allow JavaScript functions to retain access to variables that are outside of their own scope, even after those variables have been returned or otherwise passed out of the function. This makes them incredibly useful for a wide range of applications, from simple data management to more complex functional programming.

In this article, we will take a deep dive into closures in JavaScript, explaining what they are, how they work, and why they are so important. We'll also provide plenty of examples to help illustrate the concepts.

What are closures?

At its most basic level, a closure is a function that has access to its parent scope, even after the parent function has returned. In JavaScript, this means that a closure can access variables and functions that were declared outside of its own scope, as long as those variables and functions are within the same lexical scope.

In other words, a closure is created when a function is defined inside of another function, and the inner function retains access to the outer function's variables and parameters, even after the outer function has completed its execution.

Here's an example to help illustrate the concept:

function outerFunction() {
  const outerVar = 'I am outside!';

  function innerFunction() {
    console.log(outerVar);
  }

  return innerFunction;
}

const innerFunc = outerFunction();
innerFunc(); // Output: "I am outside!"

In this example, we have an outer function called outerFunction, which declares a variable called outerVar. Inside of outerFunction, we have another function called innerFunction, which simply logs the value of outerVar to the console.

The key thing to note here is that innerFunction is returned by outerFunction, and is assigned to the variable innerFunc. When we call innerFunc() later on, we see that it logs the value of outerVar to the console, even though outerVar is not declared within innerFunction itself.

This is the power of closures - innerFunction retains access to outerVar even after outerFunction has returned, because innerFunction is a closure that has access to the lexical scope of outerFunction.

How do closures work?

To understand how closures work, it's important to understand a few key concepts in JavaScript, including the lexical scope and the call stack.

Lexical scope refers to the way that variables and functions are scoped based on their location within the code. In JavaScript, variables that are declared outside of a function have a global scope, while variables declared inside of a function have a local scope that is limited to that function.

The call stack, on the other hand, is a data structure that keeps track of the functions that are currently being executed in the code. When a function is called, it is added to the top of the call stack, and when it completes its execution, it is removed from the stack.

When a closure is created, it essentially "captures" the variables and functions from its parent scope and creates a new scope that contains those captured variables and functions. This new scope is then added to the call stack, along with the function that created the closure.

This means that when a closure is called, it has access to both its scope and the parent scope that it "captured" when it was created. It can also access any variables or functions that are in the global scope if needed.

Here's another example to help illustrate the concept:

function createCounter() {
  let count = 0;

  return function() {
    count++;
    console.log(count);
  }
const counter = createCounter();

counter(); // Output: 1
counter(); // Output: 2
counter(); // Output: 3

output is 1, 2, and 3, respectively. This is because each time we call counter, it is incrementing the value of count and logging it to the console.

Why are closures important?

Closures are an incredibly powerful tool in JavaScript, and they are used in a wide range of applications. Here are just a few examples:

  • Managing private state: Because closures allow functions to retain access to variables that are outside of their own scope, they can be used to create private variables and functions that are not accessible from outside the function. This can be useful for encapsulating code and preventing it from being modified or accessed by other parts of the program.

  • Implementing currying and partial application: Closures can also be used to implement functional programming techniques like currying and partial application. These techniques allow functions to be "partially applied" to certain arguments, which can be useful for creating more flexible and reusable code.

  • Creating event handlers: Closures are commonly used in JavaScript to create event handlers. When an event listener is created, a closure is created that retains access to the event object and any other relevant data. This allows the event listener to respond appropriately to the event when it is triggered.

    Conclusion:

    Closures are a fundamental concept in JavaScript that allow functions to retain access to variables that are outside of their own scope. This makes them incredibly powerful and useful for a wide range of applications, from managing private state to implementing functional programming techniques. Understanding closures are essential for any JavaScript developer who wants to write flexible, reusable, and maintainable code.