闭包是JavaScript中的一个特性，函数可以访问自己的作用域变量、外部函数变量和全局变量。

闭包即使在外部函数返回之后也可以访问它的外部函数作用域。这意味着闭包可以记住并访问它的外部函数的变量和参数，即使函数已经完成。

内部函数可以访问在自己的作用域、外部函数的作用域和全局作用域中定义的变量。外部函数可以访问在自己的作用域和全局作用域中定义的变量。

闭包的例子:

var globalValue = 5;

function functOuter() {
  var outerFunctionValue = 10;

  //Inner function has access to the outer function value
  //and the global variables
  function functInner() {
    var innerFunctionValue = 5;
    alert(globalValue + outerFunctionValue + innerFunctionValue);
  }
  functInner();
}
functOuter();  

输出将为20，即其内部函数自身变量、外部函数变量和全局变量值的和。

凯尔的回答很好。我认为唯一需要澄清的是，闭包基本上是lambda函数创建时堆栈的快照。然后，当函数重新执行时，堆栈将恢复到执行函数之前的状态。因此，正如Kyle提到的，当lambda函数执行时，隐藏值(count)是可用的。

下面的示例演示了Scheme编程语言中的闭包。

首先定义一个函数，该函数定义了一个局部变量，在函数外部不可见。

; Function using a local variable
(define (function)
  (define a 1)
  (display a) ; prints 1, when calling (function)
  )
(function) ; prints 1
(display a) ; fails: a undefined

下面是同样的例子，但是现在函数使用了一个全局变量，定义在函数外部。

; Function using a global variable
(define b 2)
(define (function)
  (display b) ; prints 2, when calling (function)
  )
(function) ; prints 2
(display 2) ; prints 2

最后，这里有一个函数携带自己闭包的例子:

; Function with closure
(define (outer)
  (define c 3)
  (define (inner)
    (display c))
  inner ; outer function returns the inner function as result
  )
(define function (outer))
(function) ; prints 3

为了帮助理解闭包，研究一下如何在过程语言中实现闭包可能会很有用。本解释将遵循Scheme中闭包的简单实现。

首先，我必须介绍名称空间的概念。在Scheme解释器中输入命令时，它必须计算表达式中的各种符号并获得它们的值。例子:

(define x 3)

(define y 4)

(+ x y) returns 7

define表达式将值3存储在x的位置，将值4存储在y的位置。然后当我们调用(+ x y)时，解释器在命名空间中查找值，并能够执行该操作并返回7。

但是，在Scheme中，有些表达式允许您临时覆盖符号的值。这里有一个例子:

(define x 3)

(define y 4)

(let ((x 5))
   (+ x y)) returns 9

x returns 3

let关键字所做的是引入一个新的名称空间，x的值为5。你会注意到，它仍然可以看到y = 4，使得返回的和为9。您还可以看到，一旦表达式结束，x又回到了3。在这种情况下，x被局部值暂时掩盖了。

过程式语言和面向对象语言都有类似的概念。无论何时在函数中声明一个与全局变量同名的变量，都会得到相同的效果。

我们如何实现它呢?一种简单的方法是使用链表——头部包含新值，尾部包含旧的名称空间。当你需要查找一个符号时，你从头部开始，一直到尾部。

现在让我们暂时跳过第一类函数的实现。函数或多或少是在函数被调用时执行的一组指令，最终返回值。当我们读入一个函数时，我们可以在后台存储这些指令，并在函数被调用时运行它们。

(define x 3)

(define (plus-x y)
  (+ x y))

(let ((x 5))
  (plus-x 4)) returns ?

我们定义x为3，加-x为它的参数y，加上x的值。最后，在x被一个新的x遮蔽的环境中，我们调用加-x，这个x的值为5。如果我们只存储函数+ x的(+ xy)操作，因为我们在x = 5的情况下，返回的结果将是9。这就是所谓的动态作用域。

然而，Scheme、Common Lisp和许多其他语言都有所谓的词法作用域——除了存储操作(+ x y)之外，我们还将名称空间存储在特定的位置。这样，当我们查找值的时候，我们可以看到x，在这里，实际上是3。这是一个闭包。

(define x 3)

(define (plus-x y)
  (+ x y))

(let ((x 5))
  (plus-x 4)) returns 7

总之，我们可以使用链表来存储函数定义时名称空间的状态，从而允许我们从封闭的作用域访问变量，并且能够在不影响程序其余部分的情况下对变量进行局部屏蔽。

请看看下面的代码，以更深入地理解闭包:

        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如上所述。

闭包是JavaScript中的一个特性，函数可以访问自己的作用域变量、外部函数变量和全局变量。

闭包即使在外部函数返回之后也可以访问它的外部函数作用域。这意味着闭包可以记住并访问它的外部函数的变量和参数，即使函数已经完成。

内部函数可以访问在自己的作用域、外部函数的作用域和全局作用域中定义的变量。外部函数可以访问在自己的作用域和全局作用域中定义的变量。

闭包的例子:

var globalValue = 5;

function functOuter() {
  var outerFunctionValue = 10;

  //Inner function has access to the outer function value
  //and the global variables
  function functInner() {
    var innerFunctionValue = 5;
    alert(globalValue + outerFunctionValue + innerFunctionValue);
  }
  functInner();
}
functOuter();  

输出将为20，即其内部函数自身变量、外部函数变量和全局变量值的和。