What is the concept of closures in JavaScript? What are some examples?

What is the concept of closures in JavaScript? What are some examples?

Closures are a fundamental concept in JavaScript, and they occur when a function is defined within another function and has access to the outer function's variables. In simpler terms, a closure allows a function to "remember" the environment in which it was created, even after that outer function has finished executing. This is a powerful feature in JavaScript and is commonly used in various programming scenarios.

Here's an explanation of closures with some examples:

function outerFunction() {
  const outerVar = 'I am from coderuckFunction';
  function innerFunction() {
  return innerFunction;

const myClosure = outerFunction();
myClosure(); // Outputs: "I am from coderuckFunction"


In this example, outerFunction defines outerVar, and innerFunction is nested inside it. When outerFunction is called and assigned to myClosure, it returns innerFunction. Even though outerFunction has finished executing, innerFunction still has access to outerVar through the closure.


Closure with Parameters:

function greet(message) {
  return function(name) {
    console.log(message + ', ' + name);

const hello = greet('Hello');
const goodbye = greet('Goodbye');

hello('Alice');    // Outputs: "Hello, Alice"
goodbye('Bob');    // Outputs: "Goodbye, Bob"

Here, the greet function returns a new function that can greet a specific name with a predefined message. Each returned function "remembers" the message variable from its parent greet function.

Closures in Asynchronous Code:

function delayMessage(message, delay) {
  setTimeout(function() {
  }, delay);

delayMessage('This message is delayed', 2000);

 In this example, the anonymous function inside setTimeout forms a closure over the message variable. Even after delayMessage finishes executing, the function inside setTimeout can still access and log the message variable when it runs after the specified delay.

Closures are used in various scenarios, such as encapsulating data, creating private variables, implementing factory functions, and handling asynchronous operations. They allow for cleaner code and more flexible and modular design patterns in JavaScript applications.


Categories: Java Script Tags: #ES6, #JavaScript,

Newsletter Subcribe

Receive updates and latest news direct from our team. Simply enter your email.