What is Javascript Closures

JavaScript Closures: Unleashing the Power of Private Data and Modular Code

A closure is a special function that can remember and access variables from its outer function, even after the outer function has returned. This allows inner functions to have private data, and it can be used to create modular and reusable code.

Example 1: Counter Incrementer

Imagine you want to create a function that counts how many times it has been called. You can use a closure to keep track of the count:

function createCounter() {
let count = 0;

return function increment() {
count++;
return count;
};
}

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

In this example, the increment function can remember the count variable from its outer function, even after the createCounter function has returned. This allows the increment function to keep track of the count and return it each time it is called.

Example 2: Private Data Encapsulation

Closures can also be used to encapsulate data, which means that the data can only be accessed by the functions within the closure. This can be used to create private data that cannot be modified by other parts of the code.

function createPerson(name, email) {
let preferences = {
firstName: name,
emailAddress: email,
};

return {
getName: function() {
return preferences.firstName;
},
getEmail: function() {
return preferences.emailAddress;
},
};
}

const person = createPerson('John', 'john@example.com');
console.log(person.getName()); // John
console.log(person.getEmail()); // john@example.com

In this example, the preferences variable is private to the createPerson function. This means that the preferences variable cannot be accessed from outside of the createPerson function. The getName and getEmail functions can only access the preferences variable because they are defined within the createPerson function.

Closures are a powerful tool that can be used to write modular and reusable code. They can also be used to encapsulate data and prevent it from being modified by other parts of the code.