JavaScript Closures —

Imagine a library in JavaScript.

• 🏛️ Outer function = the library
• 📖 Inner function = a book
• 🔐 Variable = a secret note inside the library
• 🎒 Closure = the book carrying the secret note with it

🌟 The Story

Suppose we create a function called outer():

function outer() {
    let secret = "Hello JavaScript!";

    function inner() {
        console.log(secret);
    }
    return inner;
}
const myFunction = outer();
myFunction();

🧠 What happens?

Step 1: outer() creates the variable secret.

Step 2: Inside it, inner() is created.

Step 3: outer() returns inner.

Step 4: Even though outer() has finished, inner() remembers secret.

Get Raveenanagar’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

So:

outer()
   │
   ├── secret = "Hello JavaScript!"
   │
   └── inner()
          │
          └── remembers secret 🔐

When we call:

myFunction();

the output is:

Hello JavaScript!

🎒 The Easy Definition

A closure is a function that remembers and can access variables from its outer scope even after the outer function has finished executing.

🔢 A Real-Life Example: Counter

function createCounter() {
    let count = 0;

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

Why does count remember its value?

Because the returned function forms a closure around count.

⭐ Remember It Like This

Outer Function
      ↓
 creates variable
      ↓
Inner Function
      ↓
 remembers variable
      ↓
     CLOSURE 🎒

One-line exam definition:
Closure = Function + its remembered lexical environment.