上一节说了实行上下文，这节我们就乘胜追击来搞搞闭包！头疼的东西让你不再头疼！

一、函数也是援用范例的。

function f(){ console.log("not change") };

var ff = f;
 
function f(){ console.log("changed") };

ff();

//"changed"
//ff 保留着函数 f 的援用，转变f 的值， ff也变了

//来个对照，预计你就邃晓了。
var f = "not change";

var ff = f;

f = "changed";

console.log(ff);

//"not change"
//ff 保留着跟 f 一样的值，转变f 的值， ff 不会变

实在，就是援用范例 和 基础范例的 区分。

<br/>

二、函数建立一个参数，就相当于在其内部声清楚明了该变量

function f(arg){
    console.log(arg)
}

f();

//undefined

function f(arg){
    arg = 5;
    console.log(arg);
}
f();

//5

<br/>

三、参数通报，就相当于变量复制（值的通报）

基础范例时，变量保留的是数据，援用范例时，变量保留的是内存地址。参数通报，就是把变量保留的值 复制给 参数。

var o = { a: 5 };

function f(arg){
    arg.a = 6;
}

f(o);

console.log(o.a);
//6

<br/>

四、渣滓网络机制

JavaScript 具有自动渣滓网络机制，实行环境会担任治理代码实行过程当中运用的内存。函数中，平常的部分变量和函数声明只在函数实行的过程当中存在，当函数实行终了后，就会开释它们所占的内存（烧毁变量和函数）。

而js 中 主要有两种网络体式格局：

1. 标记消灭（罕见） //给变量标记为“进入环境” 和 “脱离环境”，接纳标记为“脱离环境”的变量。
2. 援用计数 // 一个援用范例值，被赋值给一个变量，援用次数加1，经由过程变量获得援用范例值，则减1，接纳为次数为0 的援用范例值。

晓得个也许状况就能够了，《JavaScript高等程序设计 第三版》 4.3节 有详解，有兴致，能够看下。.

<br/>

五、作用域

之前说过，JavaScript中的作用域不过就是两种：全局作用域和部分作用域。
依据作用域链的特征，我们晓得，作用域链是单向的。也就是说，在函数内部，能够直接接见函数外部和全局变量，函数。然则，反过来，函数外部和全局，是接见不了函数内的变量，函数的。

function testA(){
    var a = 666;
}
console.log(a);

//报错，a is not defined

var b = 566;
function testB(){
    console.log(b);
}

//566

然则，有时候，我们需要在函数外部 接见函数内部的变量，函数。平常状况下，我们是办不到的，这时候，我们就需要闭包来完成了。

<br/>

六、最先闭包！

function fa(){
    var va = "this is fa";

    function fb(){
        console.log(va);
    }
    
    return fb;
}

var fc = fa();
fc();

//"this is fa"

想要读取fa 函数内的变量 va，我们在内部定义了一个函数 fb，然则不实行它，把它返回给外部，用 变量fc接收。此时，在外部再实行fc，就读取了fa 函数内的变量 va。

<br/>

七、闭包的观点

实在，简朴点说，就是在 A 函数内部，存在 B 函数， B函数 在 A 函数 实行终了后再实行。B实行时，接见了已实行终了的 A函数内部的变量和函数。

由此可知：闭包是函数A的实行环境 以及 实行环境中的函数 B组合而组成的。

上篇文章中说过，变量等 都储存在 其地点实行环境的运动对象中，所以说是 函数A 的实行环境。

当 函数A实行终了后，函数B再实行，B的作用域中就保留着 函数A 的运动对象，因而B中能够接见 A中的 变量，函数，arguments对象。此时产生了闭包。大部分书中，都把 函数B 称为闭包，而在谷歌浏览器中，把 A函数称为闭包。

<br/>

八、闭包的实质

之前说过，当函数实行终了后，部分运动对象就会被烧毁。个中保留的变量，函数都邑被烧毁。内存中仅保留全局作用域（全局实行环境的变量对象）。然则，闭包的状况就差别了。

以上面的例子来讲，函数fb 和其地点的环境 函数fa，就组成了闭包。函数fa实行终了后，按原理说， 函数fa 实行环境中的 运动对象就应该被烧毁了。然则，由于 函数fa 实行时，个中的 函数fb 被 返回，被 变量fc 援用着。致使，函数fa 的运动对象没有被烧毁。而在厥后 fc() 实行，就是 函数fb 实行时，构建的作用域中保留着 函数fa 的运动对象，因而，函数fb 中 能够经由过程作用域链接见 函数fa 中的变量。

我已全力地说邃晓了。就看列位的了。哈哈！实在，简朴的说：就是fa函数实行终了了，其内部的 fb函数没有实行，并返回fb的援用，当fb再次实行时，fb的作用域中保留着 fa函数的运动对象。

再来个风趣典范的例子：

for (var i=1; i<=5; i++) {
    setTimeout(function(){
        console.log(i);
    },i*1000);
}

//每隔一秒输出一个6,共5个。

是否是跟你想的不一样？实在，这个例子重点就在setTimeout函数上，这个函数的第一个参数接收一个函数作为回调函数，这个回调函数并不会马上实行，它会在当前代码实行完，并在给定的时候后实行。如许就致使了上面状况的发作。

能够下面临这个例子举行变形，能够有助于你的明白把：

var i = 1;
while(i <= 5){
    setTimeout(function(){
        console.log(i);
    },i*1000)
     
    i = i+1;
}

正由于，setTimeout里的第一个函数不会马上实行，当这段代码实行完以后，i 已 被赋值为6了（即是5时，进入轮回，最后又加了1），所以 这时候再实行setTimeout 的回调函数，读取 i 的值，回调函数作用域内没有i，向上读取，上面作用域内i的值就是6了。然则 i * 1000，是马上实行的，所以，每次读的 i 值 都是对的。

这时候候，就需要应用闭包来保留每一个轮回时， i 差别的值。

function makeClosures(i){     //这里就和 内部的匿名函数组成闭包了
    var i = i;    //这步是不需要的，为了让看客们看的轻松点
    return function(){
        console.log(i);     //匿名没有实行，它能够接见i 的值，保留着这个i 的值。
    }
}

for (var i=1; i<=5; i++) {
    setTimeout(makeClosures(i),i*1000);  
    
    //这里简朴说下，这里makeClosures(i)， 是函数实行，并非传参，不是一个观点
    //每次轮回时，都实行了makeClosures函数，都返回了一个没有被实行的匿名函数
    //（这里就是返回了5个匿名函数），每一个匿名函数都是一个部分作用域，保留着每次传进来的i值
    //因而，每一个匿名函数实行时，读取`i`值，都是本身作用域内保留的值，是不一样的。所以，就得到了想要的效果
}

//1
//2
//3
//4
//5

闭包的症结就在，外部的函数实行终了后，内部的函数再实行，并接见了外部函数内的变量。

你能够在别处，或许本身想到了下面这类解法：

for (var i=1; i<=5; i++) {
    (function(i){
        setTimeout(function(){
            console.log(i);
        },i*1000);
    })(i);
}

假如你一直把这个当作闭包，那你能够看到的是差别的闭包定义吧（犀牛书和高程对闭包的定义差别）。严格来讲，这不是闭包，这是应用了马上实行函数 和 函数作用域 来处理的。

做下变形，你再看看：

for (var i=1; i<=5; i++) {
    function f(i){
        setTimeout(function(){
            console.log(i);
        },i*1000);
    };
    
    f(i);
}

如许看就很显著了吧，主如果应用了函数作用域，而运用马上实行函数，是为了简化步骤。

总结：推断是否是闭包，我总结了要满足以下三点：

1. 两个函数。有内函数 和 外函数。
2. 外函数实行终了后，内函数 还没有实行。
3. 当内函数实行时（经由过程外部援用或许返回内函数），接见了 外函数内部的 变量，函数等（说是接见，实在内函数保留着外函数的运动对象，因而，arguments对象也能够接见到）。

<br/>
<br/>

附录：

实在这道题，晓得ES6的 let 症结词，预计也想到了另一个解法：

for (let i=1; i<=5; i++) {   //这里的症结就是运用的let 症结词，来形成块级作用域
    setTimeout(function(){
        console.log(i);
    },i*1000);
}

我不晓得，人人有无迷惑啊，为啥运用了块级作用域就能够了呢。横竖我当初就纠结了半天。

11月 2日修改：

这个答案的症结就在于 块级作用域的划定规矩了。它让let 声明的变量只在{}内有效，外部是接见不了的。

做下变形：

for (var i=1; i<=5; i++) {
    let j = i;
    setTimeout(function(){
        console.log(j);
    },j*1000);
}

实在，for 轮回时，每次都邑用let 或许 var 建立一个新变量，并以之前迭代中同名变量的值将其初始化。而这里正由于运用let，致使每次轮回都邑建立一个新的块级作用域，如许，虽然setTimeout 中的匿名函数内没有 i 值，但它向上作用域读取i 值，就读到了块级作用域内 i 的值。

上面用马上实行函数模仿块级作用域，就是这个原理啦！