JavaScript的函数闭包详细解释
闭包的理解
如何产生闭包
当一个嵌套的内部(子)函数引用了嵌套的外部(父)函数的变量(函数)时, 就产生了闭包
function fn1 () { var a = 3 function fn2 () { console.log(a) } } fn1()
产生闭包的条件
函数嵌套；内部函数引用了外部函数的数据(变量/函数)，并且执行函数
闭包到底是什么
理解一: 闭包是嵌套的内部函数(绝大部分人)
理解二: 包含被引用变量(函数)的对象(极少数人)
注意: 闭包存在于嵌套的内部函数中
创建闭包的常见的方式
就是在一个函数内部创建另一个函数，通过另一个函数访问这个函数的局部变量。
//通过闭包可以返回局部变量 function box() { var user = 'Lee'; return function () { //通过匿名函数返回 box()局部变量 return user; }; } alert(box()()); //通过box()()来直接调用匿名函数返回值 var b = box(); alert(b()); //另一种调用匿名函数返回值
常见的闭包
将函数作为另一个函数的返回值
function fn1() { var a = 2 function fn2() { a++ console.log(a) } return fn2 } var f = fn1() // f就是fn2这个函数 f() // 3，当调用fn2这个函数的时候，执行到var a = 2的时候闭包就已经产生了，因为函数提前声明了 f() // 4，执行这里的时候直接执行了内部函数中的a++, 因为只产生了一个闭包
将函数作为实参传递给另一个函数调用
function showMsgDelay(msg, time) { setTimeout(function () { console.log(msg) // 只有msg才是这个引入的变量 }, time) } showMsgDelay('hello', 1000)
闭包的优点就是缺点（闭包的作用）
就是可以把局部变量驻留在内存中（延长了局部变量的生命周期），可以避免使用全局变量。(全局变量污染导致应用程序不可预测性，每个模块都可调用必将引来灾难，所以推荐使用私有的，封装的局部变量)。
让函数外部可以操作(读写)到函数内部的数据(变量/函数)
//通过全局变量来累加 var age = 100; //全局变量 function box() { age ++; //模块级可以调用全局变量，进行累加 } box(); //执行函数，累加了 alert(age); //输出全局变量,结果是101 box(); alert(age); //结果是102，累加了
//通过局部变量无法实现累加 function box() { var age = 100; age ++; //累加 return age; } alert(box()); //101 alert(box()); //101，无法实现，因为又被初始化了
//通过闭包可以实现局部变量的累加 function box() { var age = 100; return function () { age ++; return age; } } var b = box(); //获得函数 当不用的时候将b解除引用b=null，等待垃圾回收 alert(b()); //调用匿名函数，间接操作了外部函数中的局部变量 alert(b()); //第二次调用匿名函数，实现累加
由于闭包里作用域返回的局部变量资源不会被立刻销毁回收，所以可能会占用更多的内存。过度使用闭包会导致性能下降，建议在非常有必要的时候才使用闭包。
在使用完闭包后将b解除引用，这样就不会一直占据着内存了
闭包的生命周期
产生: 在嵌套内部函数定义执行完时就产生了(不是在调用)
死亡: 在嵌套的内部函数成为垃圾对象时
function fun1() { //此处闭包已经产生（函数提升，内部函数对象已经创建了） var a = 3; function fun2() { a++; console.log(a); } return fun2; } var f = fun1(); f(); f(); f = null //此时闭包对象死亡（包含闭包的函数对象成为了垃圾）
闭包的问题：循环里包含匿名函数
作用域链的机制导致一个问题，在循环中里的匿名函数取得的任何变量都是最后一个值。
//循环里包含匿名函数 function box() { var arr = []; for (var i = 0; i < 5; i++) { arr[i] = function () { return i; }; } return arr; } var b = box(); //调用这个函数，返回一个数组，数组中的元素是循环里的匿名函数本身 alert(b.length); //得到的数组长度结果是5 for (var i = 0; i < b.length; i++) { alert(b[i]()); //输出每个函数的值，都是最后一个值（即循环里执行到最后一步的i++，是5） }
上面的例子输出的结果都是 5，也就是循环后得到的最大的 i 值。
因为 b[i]调用的是匿名函数，匿名函数并没有自我执行，等到调用的时候，box()已执行完毕返回一个数组了，循环也已经结束了所以，i 早已变成 5，最终的结果就是 5 个 5。
改进上面的列子
改1：循环里包含匿名函数-改 1，自我执行匿名函数
function box() { var arr = []; for (var i = 0; i < 5; i++) { arr[i] = (function (num) { //通过自我及时执行 return num; })(i); //并且传参 } return arr; } var b = box();//返回的是数组，数组里的元素不是函数了 for (var i = 0; i < b.length; i++) { alert(b[i]); //这里返回的是数组，直接打印即可 }
我们让匿名函数进行自我执行，导致最终返回给 a[i]的是数组而不是函数了。最终导致 b[0]-b[4]中保留了 0,1,2,3,4 的值。
改进2：循环里包含匿名函数-改 2，匿名函数下再做个匿名函数
function box() { var arr = []; for (var i = 0; i < 5; i++) { arr[i] = (function (num) { //num其实在这里 return function () { //直接返回值，改 2 变成返回函数 return num; //原理和改 1 一样 } })(i); } return arr; } var b = box(); alert(b); for (var i = 0; i < b.length; i++) { alert(b[i]()); //这里通过 b[i]()函数调用即可 } //box()函数已经执行完了，为什么还能是0,1,2,3,4呢？ 因为闭包可以将变量驻留在内存中和上述的累加是一样的道理
改 1 和改 2 中，我们通过匿名函数自我执行，立即把结果赋值给 a[i]。每一个 i，是调用方通过按值传递的，所以最终返回的都是指定的递增的 i。而不是 box()函数里的 i。
闭包中的this使用问题
在闭包中使用 this 对象也可能会导致一些问题，this 对象是在运行时基于函数的执行环境绑定的，如果 this 在全局范围就是 window，如果在对象内部就指向这个对象。
而闭包却在运行时指向 window 的，因为闭包并不属于这个对象的属性或方法。
var user = 'The Window'; var obj = { user : 'The Object', getUserFunction : function () { return function () { //闭包不属于obj，里面的this指向window return this.user; }; } }; alert(obj.getUserFunction()()); //The window
使用对象冒充：可以强制指向某个对象
var user = 'The Window'; var obj = { user : 'The Object', getUserFunction : function () { return function () { //闭包不属于obj，里面的this指向window return this.user; }; } }; alert(obj.getUserFunction()()); //The window alert(obj.getUserFunction().call(obj)); //The Object
也可以从上一个作用域中得到对象
var user = 'The Window'; var obj = { user : 'The Object', getUserFunction : function () { //这里作用域的this是obj var that = this;//将这里的作用域交给that return function () { //这里作用域的this是window return that.user; }; } }; alert(obj.getUserFunction()()); //The Object
闭包测试题
闭包测试题1
<body> <script type="text/javascript"> var name = "The Window"; var object = { name: "My Object", getNameFunc: function () { return function () { return this.name; }; } }; console.log(object.getNameFunc()); // 结果是匿名函数体ƒ () {return this.name;} // 结果是The Window，因为this指向window // 总体流程是这样的getNameFunc方法是通过object对象调用的，这时候getNameFunc里的this指向的是object对象 // 但是调用getNameFunc方法返回的是一个方法，然后直接()进行直接调用，这时候方法里面的this指向的是window console.log(object.getNameFunc()()); </script> </body>
<body> <script type="text/javascript"> var name2 = "The Window"; var object2 = { name2: "My Object", getNameFunc: function () { var that = this; return function () { return that.name2; }; } }; console.log(object2.getNameFunc()); // 结果是匿名函数体ƒ () {return that.name2;} // 结果是My Object，因为that指向object2对象 // 总体流程是这样的getNameFunc方法是通过object2对象调用的，这时候getNameFunc里的this指向的是object对象 // 使用that变量记录了this的指向，这时候方法里面的that指向的是object2（使用了闭包） console.log(object2.getNameFunc()()); </script> </body>
闭包测试题2
<body>
<script>
function fun(n, o) {
console.log(o)
return {
fun: function (m) {
return fun(m, n)// 这里n使用了外部函数中的n也就是0，再次调用fun函数（外部的fun函数）参数中的o也就是n
}
}
}
var a = fun(0) // undefined
a.fun(1) // 0 ,每次调用的时候产生了新的闭包，但是没有被接收，所以就失效了，所以n一直都是第一次传进来的0
a.fun(2) // 0
a.fun(3) // 0
var b = fun(0).fun(1).fun(2).fun(3) //undefined,0,1,2
var c = fun(0).fun(1) // undefined, 0
c.fun(2) // 1
c.fun(3) // 1
</script>
</body>
