How to Create Private Variables Using Closures in JavaScript

In JavaScript, you can create private variables by defining them inside a function and returning an inner function that accesses these variables. This inner function forms a closure, keeping the variables hidden from the outside scope while allowing controlled access.

Syntax

To create private variables using closures, define variables inside an outer function and return an inner function that can access these variables. The inner function forms a closure, preserving access to the private variables even after the outer function finishes.

• Outer function: Holds private variables.
• Inner function: Accesses and manipulates private variables.
• Return: The inner function is returned to allow controlled access.

javascript

function createCounter() {
  let count = 0; // private variable
  return function() {
    count += 1;
    return count;
  };
}

Example

This example shows a counter with a private count variable. The returned function can increase and read count, but code outside cannot access count directly.

javascript

function createCounter() {
  let count = 0; // private variable
  return function() {
    count += 1;
    return count;
  };
}

const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

// Trying to access count directly will fail
console.log(typeof count); // undefined

Output

1
2
3
undefined

Common Pitfalls

One common mistake is trying to access the private variable directly from outside the closure, which will result in undefined or an error. Another is not returning the inner function, so the closure is never created.

Also, if you create multiple instances, each closure keeps its own private variable separate.

javascript

function wrongCounter() {
  let count = 0; // private variable
  count += 1; // increments but no function returned
}

const c = wrongCounter();
console.log(c); // undefined, no access to count

// Correct way:
function rightCounter() {
  let count = 0;
  return function() {
    count += 1;
    return count;
  };
}
const rc = rightCounter();
console.log(rc()); // 1

Output

undefined
1

Quick Reference

• Define private variables inside an outer function.
• Return an inner function that accesses these variables.
• Use the returned function to interact with private data.
• Each call to the outer function creates a new closure with its own private variables.

Key Takeaways

Use closures by returning inner functions to keep variables private in JavaScript.

Private variables are only accessible inside the closure, not from outside code.

Always return the inner function to create and use the closure.

Each closure instance has its own separate private variables.

Trying to access private variables directly from outside will fail.