Understanding JavaScript Closures

Published by Brayan K

Master one of JavaScript's most powerful and misunderstood features, closures, with clear practical examples.

JavaScript closures are one of the most misunderstood concepts — but they're also one of the most powerful tools for writing cleaner, safer, and more efficient code.

If you've ever wondered:

…this guide will give you a clear, simple explanation without confusion.

⭐ What Is a Closure? (Simple Definition)

A closure is created when:

A function remembers variables from the place it was created — even after that place is gone.

function createCounter() {
  let count = 0;

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

const counter = createCounter();
counter(); // 1
counter(); // 2

Even though createCounter() has finished running, the inner function still remembers:

That memory is the closure.

🧠 Why Closures Matter So Much

Closures allow you to:

If you ever plan to work with:

…you will use closures constantly.

🔍 Deep Explanation: How Closures Actually Work

When JavaScript executes code, it uses something called:

A function can access variables defined where it was created, not where it was called.

let name = "Boopie";

function sayName() {
  console.log(name); // Uses the outer variable
}

sayName();

But closures go even further:

If the outer function returns, the inner function keeps the variables alive.

The engine does NOT delete them — because something else still needs them.

🔒 Closures Give Us Private Variables

JavaScript doesn't have "private" variables like Java or C#…

…but closures LET US create them.

function bankAccount() {
  let balance = 0;

  return {
    deposit(amount) {
      balance += amount;
      return balance;
    },
    withdraw(amount) {
      balance -= amount;
      return balance;
    }
  };
}

const account = bankAccount();
console.log(account.deposit(50)); // 50
console.log(account.balance);     // undefined (private!)

THIS is how professional devs avoid bugs.

🎯 Real-World Uses of Closures

✅ 1. Timers & Async Functions

function delayedMessage(msg, delay) {
  setTimeout(() => console.log(msg), delay);
}

delayedMessage("Hello after 2 seconds", 2000);

The callback remembers msg and delay.

✅ 2. Event Listeners

function setupButton() {
  let clicks = 0;

  document.querySelector("button")
    .addEventListener("click", () => {
      clicks++;
      console.log("Clicked:", clicks);
    });
}

Closures allow your UI logic to remember state.

✅ 3. React Hooks

This React code works thanks to closures:

const [count, setCount] = useState(0);

State lives inside closures and updates safely.

🧩 Practical Example: Creating a Custom Counter

Here's a clean closure example you'll see in interviews:

function createCounter(start = 0) {
  let value = start;

  return {
    increment() {
      value++;
      return value;
    },
    decrement() {
      value--;
      return value;
    },
    get() {
      return value;
    }
  };
}

const counter = createCounter(10);
console.log(counter.increment()); // 11
console.log(counter.get());       // 11

This is EXACTLY how many libraries implement counters, timers, and state managers.

🚀 Tips to Fully Understand Closures

⭐ 1. Remember: Functions carry their birthplace with them

Where they were created > Where they were called.

⭐ 2. Try small experiments

Change variable names, remove scopes, test logs.

⭐ 4. Use closures to hide data

Practice creating private variables.

⭐ 5. Build small closure-based apps

Like counters, timers, settings managers, or event trackers.

🏁 Summary: Closures Made Simple

Closures happen automatically whenever:

They allow you to build:

Master closures → become a REAL JavaScript developer.

Related articles

Related lessons