个人明白，请人人斧正

个人明白闭包作用：

1. 闭包能够用来断绝作用域（简朴来讲能够断绝 环境变量、函数…etc）,也就是说 平常情况下 函数里说明的变量不会影响到函数表面;这就是个中的一种上风（代码之间互不影响，防止 因 说明的变量命一样形成 代码块争执）

//想必人人都瞥见这个这类函数情势
/*
运转效果就是
0 0
1 2
11 12
1 2
*/
var a = b = 0
console.log(a, b) // 0 0
+(function () {
    var a = 1
    var b = 2
    console.log(a, b) // 1 2
    function fn () {
         var a = 11
         var b = 12
        console.log(a,b)
    }
    function fnz () {
        console.log(a, b) 
    }
    fn()  // 11 12
    fnz() // 1 2
}())

剖析上面代码块：
第一个console, 输出00， 为何？因为在全局环境下， 此时运转console.log(a, b) 就会 找到 声明在全局的 a,b = 0.

第二个console, 因为是在匿名函数里，当运转console时，就会先找匿名函数里有无声明a,b,擦，在妈妈肚子里真找到了a,b变量，就不必去全局奶奶肚子里去找了。就此停止 输出 1 2。

第三个console 是在fn里的, 因为 fn 在 匿名函数妈妈的肚子里，然则 fn 也是个自力的个别，hihi，
当运转console时，发明 fn函数里用 a,b的声明，就不必再进一步去匿名函数妈妈肚子里去找了。
直接就输出 11 12.

第四个console 是在 fnz 里， 然则 fnz 没有 a、b 的声明,所以当console运转时， 就去匿名函数妈妈的肚子里去找， 果真找到了。查找就此结束， 不在去打搅奶奶了。 输出 1，2.

总结，书中写的作用域链

2.复用代码，复用设置，削减代码量。

 // 以下代码不是为了装x
 // 传进去一个函数 a 输出一个 新的函数 b. 相称于给函数a 增加了新的功用。 这就是 thrFn 函数的作用，封装逻辑，供应新的功用
// fn 相称于 a 函数
 var thrFn  = function (fn, time, maxLog) {
                var timeK = null
                // 
                var oTime = new Date().getTime()
                var execFn = function () {
                    fn()
                    oTime = new Date().getTime()
                }
                // 相称与 b 函数
                return function () {
                    var nTime = new Date().getTime()
                    clearTimeout(timeK)
                    if (nTime - oTime > maxLog) {
                        execFn()
                    } else {
                        timeK = setTimeout(execFn, time)
                    }
                }
    }

我的 javascript 撙节函数 与 消抖 函数 剖析传送门

神烦以下， 我就觉得出题…

var a = []
var b = []
var c = []
for(var i = 0; i < 8; i++) {
    a[i] = function () {
        console.log(i)
    }
}
for(var j = 0; j < 8; j++) {
    b[j] = (function (j) {
        return function () {
            console.log(j)
        }
    })(j)
}
for(var k = 0; k < 8; k++) {
    c[k] = (function () {
        return function () {
            console.log(k)
        }
    })(k)
}
a[6]() // 8
b[6]() // 6
c[6]() // 8

假如你觉得，你真的懂闭包，请看一遍 redux 源码， 尤其是中间件 设想的那一部份。