不包含自由变量的函数称为纯函数。

包含一个或多个自由变量的函数称为闭包。

var pure = function pure(x){
  return x 
  // only own environment is used
}

var foo = "bar"

var closure = function closure(){
  return foo 
  // foo is a free variable from the outer environment
}

src: https://leanpub.com/javascriptallongesix/read # leanpub-auto-if-functions-without-free-variables-are-pure-are-closures-impure

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

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

为了帮助理解闭包，研究一下如何在过程语言中实现闭包可能会很有用。本解释将遵循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

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

变量作用域

声明局部变量时，该变量具有作用域。一般来说，局部变量只存在于声明它们的块或函数中。

function() {
  var a = 1;
  console.log(a); // works
}    
console.log(a); // fails

如果我试图访问一个局部变量，大多数语言都会在当前作用域中查找它，然后向上遍历父作用域，直到到达根作用域。

var a = 1;
function() {
  console.log(a); // works
}    
console.log(a); // works

当一个块或函数被处理完，它的局部变量就不再需要了，通常会耗尽内存。

这就是我们通常期望的事情的运作方式。

闭包是一个持久的局部变量作用域

闭包是一个持久作用域，即使在代码执行已经移出该块之后，它仍然保留局部变量。支持闭包的语言(如JavaScript、Swift和Ruby)将允许您保留对作用域(包括其父作用域)的引用，即使在声明这些变量的块已经完成执行之后，只要您在某处保留对该块或函数的引用。

作用域对象及其所有局部变量都绑定到函数，只要函数存在，它们就会存在。

这给了我们函数可移植性。我们可以预期，在函数第一次定义时在作用域中的任何变量，在稍后调用该函数时仍然在作用域中，即使我们在完全不同的上下文中调用该函数。

例如

下面是一个非常简单的JavaScript示例，可以说明这一点:

outer = function() {
  var a = 1;
  var inner = function() {
    console.log(a);
  }
  return inner; // this returns a function
}

var fnc = outer(); // execute outer to get inner 
fnc();

这里我定义了一个函数中的函数。内部函数可以访问外部函数的所有局部变量，包括a。变量a在内部函数的作用域内。

正常情况下，当一个函数退出时，它的所有局部变量都会消失。但是，如果我们返回inner函数并将其赋值给变量fnc，以便在outer退出后它仍然存在，那么定义inner时在作用域内的所有变量也将仍然存在。变量a已经被关闭了——它在一个闭包中。

注意变量a对于fnc是完全私有的。这是在函数式编程语言(如JavaScript)中创建私有变量的一种方式。

正如你可能猜到的那样，当我调用fnc()时，它会打印a的值，即“1”。

在没有闭包的语言中，当函数outer退出时，变量a将被垃圾收集并丢弃。调用fnc将抛出一个错误，因为a不再存在。

在JavaScript中，变量a持续存在，因为变量作用域是在函数第一次声明时创建的，并且只要函数继续存在，变量a就会持续存在。

A属于outer的范围。inner的作用域有一个父指针指向outer的作用域。FNC是一个指向内的变量。只要FNC存在，A就存在。A在闭包内。

进一步阅读(观看)

我制作了一个YouTube视频，介绍了这段代码的一些实际使用示例。

从Lua.org:

当一个函数被封装在另一个函数中编写时，它可以完全访问封装函数中的局部变量;这个特性称为词法作用域。尽管这听起来很明显，但事实并非如此。词法作用域加上第一类函数是编程语言中一个强大的概念，但很少有语言支持这个概念。

闭包为JavaScript提供状态。

状态在编程中仅仅意味着记忆。

例子

var a = 0;

a = a + 1; // => 1
a = a + 1; // => 2
a = a + 1; // => 3

在上面的例子中，state存储在变量“a”中。我们在a后面加几次1。我们之所以能够这样做，是因为我们能够“记住”这个值。状态符“a”将该值保存在内存中。

通常，在编程语言中，您希望跟踪事物、记住信息并在以后访问它。

在其他语言中，这通常是通过使用类来实现的。类，就像变量一样，跟踪它的状态。而该类的实例，依次在它们内部也有状态。状态仅仅意味着您以后可以存储和检索的信息。

例子

class Bread {
  constructor (weight) {
    this.weight = weight;
  }

  render () {
    return `My weight is ${this.weight}!`;
  }
}

我们如何从“渲染”方法中访问“权重”?好吧，感谢国家。Bread类的每个实例都可以通过从“状态”(内存中存储信息的地方)读取它来呈现自己的权重。

JavaScript是一种非常独特的语言，它在历史上没有类(现在有了，但在底层只有函数和变量)，所以闭包为JavaScript提供了一种记忆事物并在以后访问它们的方法。

例子

var n = 0;
var count = function () {
  n = n + 1;
  return n;
};

count(); // # 1
count(); // # 2
count(); // # 3

上面的例子实现了用变量“保持状态”的目标。这太棒了!然而，这有一个缺点，即变量(“状态”holder)现在是公开的。我们可以做得更好。我们可以使用闭包。

例子

var countGenerator = function () {
  var n = 0;
  var count = function () {
    n = n + 1;
    return n;
  };

  return count;
};

var count = countGenerator();
count(); // # 1
count(); // # 2
count(); // # 3

这太棒了。

现在我们的count函数可以计数了。它之所以能够这样做，是因为它可以“保持”状态。这种情况下的状态是变量“n”。这个变量现在关闭了。在时间和空间上封闭。因为你永远无法恢复它，改变它，给它赋值或直接与它交互。在空间中，因为它在地理上嵌套在“countGenerator”函数中。

为什么这很神奇?因为不需要涉及任何其他复杂的工具(例如类、方法、实例等)，我们就能够 1. 隐藏 2. 从远处控制

我们隐藏了状态，变量“n”，这使它成为一个私有变量! 我们还创建了一个API，可以以预定义的方式控制这个变量。特别地，我们可以像这样调用API“count()”，它从“距离”将1加到“n”。除非通过API，否则任何人都无法访问“n”。

JavaScript的简单性确实令人惊叹。

闭包是其中一个重要原因。