我问了一个关于curry和闭包的问题。 什么是闭包?它和咖喱有什么关系?
当前回答
请看看下面的代码，以更深入地理解闭包:
for(var i=0; i< 5; i++){
setTimeout(function(){
console.log(i);
}, 1000);
}
这里会输出什么?0 1 2 3 4不是5 5 5 5 5 5 5 5 5因为是闭包的
那么它将如何解决呢?答案如下:
for(var i=0; i< 5; i++){
(function(j){ //using IIFE
setTimeout(function(){
console.log(j);
},1000);
})(i);
}
让我简单解释一下，当一个函数创建时，直到它在第一个代码中调用5次for循环才会发生，但不会立即调用所以当它在1秒后调用i.e时，这也是异步的，所以在这个for循环结束之前，将值5存储在var i中最后执行5次setTimeout函数并打印5,5,5,5,5
这里如何解决使用IIFE即立即调用函数表达式
(function(j){ //i is passed here
setTimeout(function(){
console.log(j);
},1000);
})(i); //look here it called immediate that is store i=0 for 1st loop, i=1 for 2nd loop, and so on and print 0,1,2,3,4
要了解更多，请了解执行上下文以理解闭包。
还有一个解决方案来解决这个问题，使用let (ES6特性)，但在引子下面，上面的函数是工作的 (让我= 0;我< 5;我+ +){ setTimeout(函数(){ console.log(我); }, 1000); ｝ 输出:0,1,2,3,4
更多解释:
在内存中，当for循环执行时，图片如下所示:
1)循环
setTimeout(function(){
console.log(i);
},1000);
2)循环
setTimeout(function(){
console.log(i);
},1000);
3)循环
setTimeout(function(){
console.log(i);
},1000);
4)循环
setTimeout(function(){
console.log(i);
},1000);
循环5)
setTimeout(function(){
console.log(i);
},1000);
这里没有执行i，然后在完成循环后，var i在内存中存储值5，但它的作用域在它的子函数中始终可见，因此当函数在setTimeout内执行五次时，它打印5,5,5,5,5
所以解决这个问题使用IIFE如上所述。
其他回答
首先，与这里大多数人告诉你的相反，闭包不是一个函数!那么它是什么呢? 它是在函数的“周围上下文”(称为其环境)中定义的一组符号，使其成为CLOSED表达式(即，每个符号都被定义并具有值的表达式，因此可以对其求值)。
例如，当你有一个JavaScript函数:
function closed(x) {
return x + 3;
}
它是一个封闭表达式，因为其中出现的所有符号都在其中定义(它们的含义是明确的)，所以您可以对其求值。换句话说，它是独立的。
但如果你有一个这样的函数
function open(x) {
return x*y + 3;
}
它是一个开放的表达式，因为其中有尚未定义的符号。也就是y，当我们看这个函数的时候，我们不知道y是什么，它意味着什么，我们不知道它的值，所以我们不能计算这个表达式。也就是说，我们不能调用这个函数，直到我们知道y在其中的含义。这个y叫做自由变量。
这需要一个定义，但这个定义不是函数的一部分——它是在其他地方定义的，在它的“周围上下文”(也称为环境)中。至少这是我们所希望的:P
例如，它可以被全局定义:
var y = 7;
function open(x) {
return x*y + 3;
}
或者它可以定义在一个包装它的函数中:
var global = 2;
function wrapper(y) {
var w = "unused";
return function(x) {
return x*y + 3;
}
}
环境中赋予表达式中自由变量意义的部分是闭包。之所以这么叫，是因为它通过为所有自由变量提供这些缺失的定义，把一个开放表达式变成一个封闭表达式，这样我们就可以求值了。
在上面的例子中，内部函数(我们没有给出名称，因为我们不需要它)是一个开放表达式，因为其中的变量y是自由的——它的定义在函数之外，在包装它的函数中。这个匿名函数的环境是一组变量:
{
global: 2,
w: "unused",
y: [whatever has been passed to that wrapper function as its parameter `y`]
}
闭包是这个环境的一部分，它通过提供所有自由变量的定义来关闭内部函数。在我们的例子中，内部函数中唯一的自由变量是y，所以这个函数的闭包是它环境的这个子集:
{
y: [whatever has been passed to that wrapper function as its parameter `y`]
}
在环境中定义的另外两个符号不是该函数闭包的一部分，因为它不需要运行它们。他们不需要关闭它。
这里有更多的理论: https://stackoverflow.com/a/36878651/434562
It's worth to note that in the example above, the wrapper function returns its inner function as a value. The moment we call this function can be remote in time from the moment the function has been defined (or created). In particular, its wrapping function is no longer running, and its parameters which has been on the call stack are no longer there :P This makes a problem, because the inner function needs y to be there when it is called! In other words, it requires the variables from its closure to somehow outlive the wrapper function and be there when needed. Therefore, the inner function has to make a snapshot of these variables which make its closure and store them somewhere safe for later use. (Somewhere outside the call stack.)
And this is why people often confuse the term closure to be that special type of function which can do such snapshots of the external variables they use, or the data structure used to store these variables for later. But I hope you understand now that they are not the closure itself – they're just ways to implement closures in a programming language, or language mechanisms which allows the variables from the function's closure to be there when needed. There's a lot of misconceptions around closures which (unnecessarily) make this subject much more confusing and complicated than it actually is.
请看看下面的代码，以更深入地理解闭包:
for(var i=0; i< 5; i++){
setTimeout(function(){
console.log(i);
}, 1000);
}
这里会输出什么?0 1 2 3 4不是5 5 5 5 5 5 5 5 5因为是闭包的
那么它将如何解决呢?答案如下:
for(var i=0; i< 5; i++){
(function(j){ //using IIFE
setTimeout(function(){
console.log(j);
},1000);
})(i);
}
让我简单解释一下，当一个函数创建时，直到它在第一个代码中调用5次for循环才会发生，但不会立即调用所以当它在1秒后调用i.e时，这也是异步的，所以在这个for循环结束之前，将值5存储在var i中最后执行5次setTimeout函数并打印5,5,5,5,5
这里如何解决使用IIFE即立即调用函数表达式
(function(j){ //i is passed here
setTimeout(function(){
console.log(j);
},1000);
})(i); //look here it called immediate that is store i=0 for 1st loop, i=1 for 2nd loop, and so on and print 0,1,2,3,4
要了解更多，请了解执行上下文以理解闭包。
还有一个解决方案来解决这个问题，使用let (ES6特性)，但在引子下面，上面的函数是工作的 (让我= 0;我< 5;我+ +){ setTimeout(函数(){ console.log(我); }, 1000); ｝ 输出:0,1,2,3,4
更多解释:
在内存中，当for循环执行时，图片如下所示:
1)循环
setTimeout(function(){
console.log(i);
},1000);
2)循环
setTimeout(function(){
console.log(i);
},1000);
3)循环
setTimeout(function(){
console.log(i);
},1000);
4)循环
setTimeout(function(){
console.log(i);
},1000);
循环5)
setTimeout(function(){
console.log(i);
},1000);
这里没有执行i，然后在完成循环后，var i在内存中存储值5，但它的作用域在它的子函数中始终可见，因此当函数在setTimeout内执行五次时，它打印5,5,5,5,5
所以解决这个问题使用IIFE如上所述。
凯尔的回答很好。我认为唯一需要澄清的是，闭包基本上是lambda函数创建时堆栈的快照。然后，当函数重新执行时，堆栈将恢复到执行函数之前的状态。因此，正如Kyle提到的，当lambda函数执行时，隐藏值(count)是可用的。
我将给出一个例子(JavaScript):
function makeCounter () {
var count = 0;
return function () {
count += 1;
return count;
}
}
var x = makeCounter();
x(); returns 1
x(); returns 2
...etc...
这个makeCounter函数的作用是，它返回一个函数，我们称之为x，每次调用它都会加1。由于我们没有为x提供任何参数，它必须以某种方式记住计数。它知道根据所谓的词法作用域在哪里找到它——它必须查找定义值的位置才能找到值。这个“隐藏”值就是所谓的闭包。
下面还是我用咖喱的例子:
function add (a) {
return function (b) {
return a + b;
}
}
var add3 = add(3);
add3(4); returns 7
您可以看到，当您使用参数a(即3)调用add时，该值包含在我们定义为add3的返回函数的闭包中。这样，当我们调用add3时，它知道在哪里找到a值来执行加法。
封闭非常简单。我们可以这样考虑: 闭包=函数+它的词汇环境
考虑以下函数:
function init() {
var name = “Mozilla”;
}
在上述情况下，闭包是什么? 函数init()及其词法环境中的变量，即name。 闭包= init() + name
考虑另一个函数:
function init() {
var name = “Mozilla”;
function displayName(){
alert(name);
}
displayName();
}
这里的闭包是什么? 内部函数可以访问外部函数的变量。displayName()可以访问父函数init()中声明的变量名。但是，如果displayName()中存在相同的局部变量，则将使用它们。
闭包1:init函数+ (name变量+ displayName()函数)——>词法作用域
闭包2:displayName函数+(名称变量)——>词法范围
