Breaking News: Grepper is joining You.com. Read the official announcement!

what are closures

Add Answer

Lively Lion answered on July 19, 2021 Popularity 8/10 Helpfulness 3/10

answer what are closures

related Closure ()

related closures in javascript

related Closures in javascript

related How do JavaScript closures work?

related how javascript closures work?

related JavaScript - Closures

related what is closure in JavaScript

related JavaScript Closures

related Closure Example

related JavaScript Closures

what are closures

Comment

Closures are related and often confused with lambda functions.
The 2 concepts are wonderfully explained and distinguished 
in this StackOverflow answer :
https://stackoverflow.com/a/36878651/13574304

Popularity 8/10 Helpfulness 3/10 Language javascript

Source: Grepper

Tags: closures javascript

Link to this answer
Share Copy Link

Contributed on May 27 2022

Lively Lion

0 Answers Avg Quality 2/10

Closely Related Answers

Closure ()

Comment

// Closures
// In JavaScript, closure is one of the widely discussed and important concepts.
// A closure is a function that has access to the variable from another function’s scope which is accomplished by creating a function inside a function. As defined on MDN:
// “Closures are functions that refer to independent (free) variables. In other words, the function defined in the closure ‘remembers’ the environment in which it was created.”
// In JavaScript, closures are created every time a function is created, at function creation time. Most JavaScript developers use closure consciously or unconsciously — but knowing closure provides better control over the code when using them.
// Example:

function Spellname(name) {
var greet = "Hi, " + name + "!";
var sName = function() {
var welc = greet + " Good Morning!";
console.log(greet);
};
return sName;
}
var Myname = SpellName("Nishi");
Myname();  // Hi, Nishi. Good Morning!

// In the above example, the function sName() is closure; it has its own local scope (with variable welc) and also has access to the outer function’s scope. After the execution of Spellname(), the scope will not be destroyed and the function sName() will still have access to it.

Popularity 10/10 Helpfulness 4/10 Language javascript

Source: betterprogramming.pub

Tags: javascript j

Link to this answer
Share Copy Link

Contributed on Dec 20 2021

Meandering Meerkat

0 Answers Avg Quality 2/10

closures in javascript

Comment

// A closure is a function having access to the parent scope, 
// even after the parent function has popped.

function greeting() {
    let message = 'Hi';

    function sayHi() {
        console.log(message);
    }

    return sayHi;
}
let hi = greeting();
hi(); // still can access the message variable

Popularity 10/10 Helpfulness 4/10 Language javascript

Source: www.javascripttutorial.net

Tags: closures closure

Link to this answer
Share Copy Link

Contributed on Feb 01 2022

madhav

0 Answers Avg Quality 2/10

Closures in javascript

Comment

let counter = (function() {
    let i = 0; // private property

    return {   // public methods
        get: function() {
            alert(i);
        },
        set: function(value) {
            i = value;
        },
        increment: function() {
            alert(++i);
        }
    };
})(); // module

counter.get();      // shows 0
counter.set(6);
counter.increment(); // shows 7
counter.increment(); // shows 8

Popularity 10/10 Helpfulness 3/10 Language javascript

Source: en.wikipedia.org

Tags: closures closure

Link to this answer
Share Copy Link

Contributed on Apr 29 2022

Ali Salman

0 Answers Avg Quality 2/10

How do JavaScript closures work?

Comment

/*
A lexical environment is part of every execution context (stack frame) and is a map between identifiers (i.e. local variable names) and values.

Every function in JavaScript maintains a reference to its outer lexical environment. This reference is used to configure the execution context created when a function is invoked. 
This reference enables code inside the function to "see" variables declared outside the function, regardless of when and where the function is called.

If a function was called by a function, which in turn was called by another function, then a chain of references to outer lexical environments is created.
This chain is called the scope chain.

In the following code, inner forms a closure with the lexical environment of the execution context created when foo is invoked, closing over variable secret:
*/
function foo() {
  const secret = Math.trunc(Math.random() * 100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`
 Run code snippet

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: stackoverflow.com

Tags: closures closure

Link to this answer
Share Copy Link

Contributed on Jun 22 2022

Sleepy Squirrel

0 Answers Avg Quality 2/10

how javascript closures work?

Comment

function foo() {
  const secret = Math.trunc(Math.random() * 100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`
 Run code snippet

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: stackoverflow.com

Tags: closures closure

Link to this answer
Share Copy Link

Contributed on Jun 16 2022

Himanshu Jangid

0 Answers Avg Quality 2/10

JavaScript - Closures

Comment

function makeAdder(x) {
  return function(y) {
    return x + y;
  };
}

var add5 = makeAdder(5);
var add10 = makeAdder(10);

console.log(add5(2));  // 7
console.log(add10(2)); // 12

//=====
//add5 and add10 are both closures. 
//They share the same function body definition, but store different lexical environments. 
//In add5's lexical environment, x is 5, while in the lexical environment for add10, x is 10.

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: developer.mozilla.org

Tags: closures closure

Link to this answer
Share Copy Link

Contributed on Jul 19 2021

The Arborist

0 Answers Avg Quality 2/10

what is closure in JavaScript

Comment

A combination of a function object and a scope (a set of variable bindings)

in which the function's variables are resolved is called a closure.

Callbacks are functions that are passed into another function as an argument.

Closures are functions that are nested in other functions, and it's often used to avoid scope clash

with other parts of a JavaScript program

<button type="button" onclick="funClosure()">Click to Count</button>

<p id="displayValue">0</p>
<script>
const add = (function(){
	let count = 0;
    return function(){
		count += 1;
        return count;
    }
})();

function funClosure(){
  document.getElementById("displayValue").innerHTML = add();
}
</script>

Popularity 9/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: javascript j

Link to this answer
Share Copy Link

Contributed on Mar 31 2023

@CodeGrepperManu

0 Answers Avg Quality 2/10

JavaScript Closures

Comment

// javascript closure example

// outer function
function greet() {
    // variable defined outside the inner function
    let name = 'John';
    // inner function
    function displayName() {

        // accessing name variable
        return 'Hi' + ' ' + name;
      
    }
    return displayName;
}

const g1 = greet();
console.log(g1); // returns the function definition
console.log(g1()); // returns the value

Popularity 9/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: closures closure

Link to this answer
Share Copy Link

Contributed on May 22 2022

SAMER SAEID

0 Answers Avg Quality 2/10

Closure Example

Comment

	 function Counter() {
    var counter = 0;
alert("XXXXX");
function increaseCounter()
{
return counter +=1;
} 

return increaseCounter;
}

/***/
const counter = new Counter();
console.log(counter());
console.log(counter());


/*note that alert("XXXX") only executes once*/
/*think of counter() = new Counter() declaration as storing the value of ONE Counter function execution and 
the remaining times you use counter(), you reexecute only the returned function*/
/*use counter() instead of Counter() if you want alert("XXXX") to execute only once AND for you to be able to return an actual value otherwise you only console.log a function and alert executes multiple times*/

Popularity 9/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: javascript j

Link to this answer
Share Copy Link

Contributed on Jun 15 2022

Javasper

0 Answers Avg Quality 2/10

JavaScript Closures

Comment

function createCounter() {
  var count = 0;

  return {
    increment: function() {
      count++;
    },
    decrement: function() {
      count--;
    },
    getCount: function() {
      return count;
    }
  };
}

var counter = createCounter();
counter.increment();
counter.increment();
console.log(counter.getCount()); // Output: 2

Popularity 9/10 Helpfulness 2/10 Language javascript

Source: chat.openai.com

Tags: closures closure

Link to this answer
Share Copy Link

Contributed on Jun 16 2023

Asim Ehmedov

0 Answers Avg Quality 2/10

what are closures

Contents

More Related Answers

what are closures

Closely Related Answers

Closure ()

closures in javascript

Closures in javascript

How do JavaScript closures work?

how javascript closures work?

JavaScript - Closures

what is closure in JavaScript

JavaScript Closures

Closure Example

JavaScript Closures

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.