JavaScript Function Closures
JavaScript Basics

JavaScript Function Closures

Function Closure

Understanding JavaScript Closures

Closures are a powerful feature in JavaScript that allow a function to access its lexical scope even when the function is executing outside its lexical scope. They are particularly useful for creating private variables.

Concept of Closures

A closure is formed when a function retains access to its scope (variables and functions) even after the function has executed. This happens often when a function returns another function.

Example: Counter with Closures

Consider a situation where you want a counter that can only be modified using a specific function, without exposing the counter variable to the global scope.

const createCounter = function() {  let counter = 0; // `counter` is a private variable made by the closure  return function() {    counter += 1; // Modify the private `counter` each time this function is called    return counter;  }};‍const add = createCounter();‍console.log(add()); // Outputs: 1console.log(add()); // Outputs: 2console.log(add()); // Outputs: 3

How Closures Work

  1. Local Variables with Functions: When createCounter is called, it creates a local variable counter and a function that can access and modify counter.
  2. Preserving State: Even after createCounter has finished execution, the counter remains accessible to the returned function. This is the closure.
  3. Privacy: The counter variable is completely shielded from the global scope and can only be accessed and changed by calling add.

Nested Functions and Scope

In JavaScript, nested functions can access variables of their parent function. This is because JavaScript supports lexical scoping, where inner functions have access to the variables of their outer functions.

function add() {  let counter = 0;  function plus() {    counter += 1;  }  plus();  return counter;}

Using Closures in Real Scenarios

Closures are not only useful for maintaining private variables but also for:

  • Event handlers and callbacks that need to preserve state in an asynchronous environment.
  • Partial applications or currying, where a function uses some fixed arguments.
  • Implementing features like throttling and debouncing in web development.


A JavaScript closure occurs when a function that is defined inside another function retains access to the outer function's scope even after the outer function has completed execution. This allows the function to have private variables and maintain state across multiple calls. Closures are a fundamental concept in JavaScript that facilitate more modular, maintainable, and robust code.

Take a look into your desired course