理解js闭包

总结：闭包的核心是[[scope]]属性，在函数解析过程当中，若是函数引用了外层函数的变量，那么外层函数（即便自身被销毁）的活动对象带着对应变量将会被保留，而且记录在scope属性中，做为做用域链的第二层，若是还引用了外层函数的外层函数的变量，那么对应的活动对象与变量也会被保留，并记录，将会做为做用域链的第三层，依次类推...。当函数被调用时，所取到的外部变量的值将会是调用时各个变量的值。即当前值。

闭包调用时也是普通函数，只不过做用域链多了闭包Closure的成分

闭包的用途：1.模仿块级做用域，在当即调用函数中声明内部须要使用的变量；2.管理私有变量和方法；3.函数柯里化

来个极端的例子

function closure() {
    let result = [], count = 1
    setInterval(() => {count++}, 1000)
    function outer() {
        let doufu = 'wu'
        return function inner() {
            let foo = 'foo'
            return function closureCallback() {
                let bar = {bar: 'bar'}, bar1 = 'bar'
                result[i] = function () {
                    console.log(count)
                    let b = doufu
                    return bar.bar + i
                }
            }
        }
    }
    let inner = outer()
    let closureCallback = inner()
    for (var i=0; i<10; i++) {
        // [[scope]]包含closure{result, i}
        // 函数在这里当即调用
        // i为实时值0,1,2,3...
        closureCallback()
    }
    return result
}

从图中能够看到，最终返回结果分别引用了closureCallback, outer，closure中的变量，因此，在做用域链中会保存这三个函数的活动对象，不一样时间调用，返回的count值不一样，说明引用的是当前值。
如下是手工示意图

如下是个人学习过程
JavaScript里面的闭包，指的是函数与声明该函数的词法环境的组合。
通常在函数里面声明函数，而且引用外面函数的变量，就会产生闭包。定义在全局的时候，默认不产生闭包(所谓闭包，就是当内部函数引用了外部函数中的变量时，会在函数的做用域上面添加一层，这一层包含了函数所引用的外部函数的变量，存放在scope属性里面，在调用时，用于造成做用域链)
函数在执行时，会在内存中建立一个活动对象，该活动对象包含arguments以及一些参数。并经过复制[[scope]]属性中的对象构建起执行环境的做用域链。

var bar = 'zoo'
function Foo() {
    this.bar = bar
}

function foo() {
    let bar = 'zoo'
    function zoo() {
        let zoo = bar
    }
}
foo()

function closure() {
    let result = []
    for (var i=0; i<10; i++) {
        result[i] = function () {
            return i
        }
    }
    return result
}
let arr = closure()

主要体如今函数返回函数，函数A在调用函数B时被建立并从B函数的内部返回。当咱们调用A函数的时候，B函数的做用域链已经从内存中销毁，可是咱们仍然能够在A中访问B中存在的变量。由于B中的变量仍然保存在A的活动对象中（做用域链中[[scope]]对象里面）
此时，函数A与A的scope构成closure函数的闭包实例

从图中能够看到，ar[0](如下称为函数A)函数的做用域链最顶层为自身活动对象（arguments， caller, length, name等等构成）再往上则是由一个Closure对象实例构成，能够看到这一层里面只包含一个变量i,即建立A时外层函数里面声明的变量i。当咱们调用A时，咱们在第二层做用域链上面找到的这个i变量。
为何arr数组每一项都返回的是10，而不是对应的下标值的缘由就在这里：当咱们调用数组项函数时，遇到变量i，而且在第二层做用域链读取到i，这里面保存的i就是closure函数里面定义的i。在A调用时，closure已经执完毕，在closure执行的过程当中i的值从0变到了10。这个性质相似于把本来存在于closure函数中的变量，在closure函数执行完毕后（从内存中移除）咱们能够在A自身的scope属性里访问到。
简单一点说就是咱们在调用A函数的时候，访问到的i变量，是函数closure（虽然它不在了可是它的变量还在，仍然被scope属性引用。）的当前值（实时值）

因此要达到预期目标，咱们只须要保证它的scope对象中保存的这个‘i’值是正确的就能够了。
这里面的思路就是，函数A被当作普通函数调用时，非闭包状况下，做用域就是自身（没有i变量）+ 全局做用域（也没有）,因此这里仍是须要借助闭包。即须要保证A上一层做用域的i是正确的值

1.建立另一个闭包,每一个i的值都会建立一个闭包

function closureCallback(i) {
    // 返回函数里面的i变量就是closureCallback函数的参数i
    return function() {
        return i
    }
}

function closure() {
    let result = [], b = 'closure'
    for (var i=0; i<10; i++) {
                // 这里的closureCallback做为普通函数调用
                // 且没有引用closure函数的变量，
                // 函数做用域内的变量，没法直接在函数外取得
                // 因此做用域链不包含closure
                // 因此在closureCallback函数[[scope]]中不会有closure函数
        result[i] = closureCallback(i)
    }
    return result
}

2.使用匿名闭包

function closure() {
    let result = [], b = 'closure'
    for (var i=0; i<10; i++) {
        result[i] = (function (i) {
            return () => i
        })(i)
    }
    return result
}
let arr = closure()

3.使用let，减小闭包，let具备块级做用域的效果

function closure() {
    let result = [], b = 'closure'
    for (var i=0; i<10; i++) {
        let j = i
        result[i] = function () {
            return j
        }
    }
    return result
}
let arr = closure()