Understanding Closures in JavaScript: A Beginner-Friendly Guide

In the ever-evolving world of web development, JavaScript stands as a cornerstone technology. Among its many powerful features, closures represent a fundamental concept that every aspiring JavaScript developer should understand. In this article, we will demystify closures, breaking down this concept into simple terms and illustrating it with clear, easy-to-follow examples.

What are Closures in JavaScript?

A closure in JavaScript is a function that remembers the environment in which it was created. This environment includes any variables that were in scope at the time the closure was created. Think of it as a backpack that a function carries around, containing all the resources it needs to operate.

How Do Closures Work?

To understand closures, let’s start with a basic example:

function outerFunction() {
    let outerVariable = 'I am outside!';

    function innerFunction() {

    return innerFunction;

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

In this example, innerFunction is a closure. It is defined within outerFunction, and it has access to outerVariable, a variable in outerFunction‘s scope. Even after outerFunction has finished executing, innerFunction remembers and accesses outerVariable. This is the essence of a closure.

Practical Uses of Closures

Data Encapsulation and Privacy

Closures allow for the creation of private variables that cannot be accessed directly from outside the function.

function createCounter() {
    let count = 0;
    return function() {

const myCounter = createCounter();
myCounter(); // Output: 1
myCounter(); // Output: 2

In this example, count is a private variable. The createCounter function returns a closure that manipulates count without exposing it directly.

Event Handlers and Callbacks

Closures are commonly used in event handlers and callbacks to maintain state between asynchronous operations.

for (var i = 1; i <= 3; i++) {
    setTimeout(function() {
    }, i * 1000);
// Output: 4 (three times)

Here, due to the lack of closure, the console logs 4 three times instead of 1, 2, 3. This is because the loop completes before the first setTimeout callback is executed, and i becomes 4.

Currying Functions

Closures enable currying, where a function with multiple arguments is transformed into a sequence of functions with a single argument.

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

const double = multiply(2);
console.log(double(3)); // Output: 6

multiply returns a closure that remembers the value of a.


Closures in JavaScript are an incredibly powerful tool, enabling sophisticated techniques like data encapsulation, stateful functions, and functional programming patterns. By understanding and leveraging closures, developers can write more efficient, modular, and maintainable code. Remember, the key to mastering closures lies in practice and experimentation, so don’t hesitate to try out these examples and create your own.