闭包
我们先来看一个例子：
var n = 999; function f1() { console.log(n); } f1() // 999
上面代码中，函数f1可以读取全局变量n。但是，函数外部无法读取函数内部声明的变量。
function f1() { var n = 999; } console.log(n) // Uncaught ReferenceError: n is not defined
上面代码中，函数f1内部声明的变量n，函数外是无法读取的。
如果有时需要得到函数内的局部变量。正常情况下，这是办不到的，只有通过变通方法才能实现。那就是在函数的内部，再定义一个函数。
function f1() { var n = 999; function f2() { console.log(n); // 999 } }
上面代码中，函数f2就在函数f1内部，这时f1内部的所有局部变量，对f2都是可见的。既然f2可以读取f1的局部变量，那么只要把f2作为返回值，我们不就可以在f1外部读取它的内部变量了吗！
二、闭包是什么
我们可以对上面代码进行如下修改：
function f1(){ var a = 999; function f2(){ console.log(a); } return f2; // f1返回了f2的引用 } var result = f1(); // result就是f2函数了 result(); // 执行result，全局作用域下没有a的定义， //但是函数闭包，能够把定义函数的时候的作用域一起记住，输出999
上面代码中，函数f1的返回值就是函数f2，由于f2可以读取f1的内部变量，所以就可以在外部获得f1的内部变量了。
闭包就是函数f2，即能够读取其他函数内部变量的函数。由于在JavaScript语言中，只有函数内部的子函数才能读取内部变量，因此可以把闭包简单理解成“定义在一个函数内部的函数”。闭包最大的特点，就是它可以“记住”诞生的环境，比如f2记住了它诞生的环境f1，所以从f2可以得到f1的内部变量。在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
那到底什么是闭包呢？
当函数可以记住并访问所在的词法作用域，即使函数是在当前词法作用域之外执行，这就产生了闭包。 ----《你不知道的Javascript上卷》
我个人理解，闭包就是函数中的函数(其他语言不能函数再套函数),里面的函数可以访问外面函数的变量，外面的变量的是这个内部函数的一部分。
闭包形成的条件
- 函数嵌套
- 内部函数引用外部函数的局部变量
三、闭包的特性
每个函数都是闭包，每个函数天生都能够记忆自己定义时所处的作用域环境。把一个函数从它定义的那个作用域，挪走，运行。这个函数居然能够记忆住定义时的那个作用域。不管函数走到哪里，定义时的作用域就带到了哪里。接下来我们用两个例子来说明这个问题：
//例题1 var inner; function outer(){ var a=250; inner=function(){ alert(a);//这个函数虽然在外面执行，但能够记忆住定义时的那个作用域，a是250 } } outer(); var a=300; inner();//一个函数在执行的时候，找闭包里面的变量，不会理会当前作用域。
//例题2 function outer(x){ function inner(y){ console.log(x+y); } return inner; } var inn=outer(3);//数字3传入outer函数后，inner函数中x便会记住这个值 inn(5);//当inner函数再传入5的时候，只会对y赋值，所以最后弹出8
四、闭包的内存泄漏
栈内存提供一个执行环境，即作用域，包括全局作用域和私有作用域,那他们什么时候释放内存的？
- 全局作用域----只有当页面关闭的时候全局作用域才会销毁
- 私有的作用域----只有函数执行才会产生
一般情况下，函数执行会形成一个新的私有的作用域，当私有作用域中的代码执行完成后，我们当前作用域都会主动的进行释放和销毁。但当遇到函数执行返回了一个引用数据类型的值，并且在函数的外面被一个其他的东西给接收了，这种情况下一般形成的私有作用域都不会销毁。
如下面这种情况：
function fn(){ var num=100; return function(){ } } var f=fn();//fn执行形成的这个私有的作用域就不能再销毁了
也就是像上面这段代码，fn函数内部的私有作用域会被一直占用的，发生了内存泄漏。所谓内存泄漏指任何对象在您不再拥有或需要它之后仍然存在。闭包不能滥用，否则会导致内存泄露，影响网页的性能。闭包使用完了后，要立即释放资源，将引用变量指向null。
接下来我们看下有关于内存泄漏的一道经典面试题：
function outer(){ var num=0;//内部变量 return function add(){//通过return返回add函数，就可以在outer函数外访问了 num++;//内部函数有引用，作为add函数的一部分了 console.log(num); }; } var func1=outer(); func1();//实际上是调用add函数， 输出1 func1();//输出2 因为outer函数内部的私有作用域会一直被占用 var func2=outer(); func2();// 输出1 每次重新引用函数的时候，闭包是全新的。 func2();// 输出2
五、闭包的作用
1.可以读取函数内部的变量。
2.可以使变量的值长期保存在内存中，生命周期比较长。因此不能滥用闭包，否则会造成网页的性能问题
3.可以用来实现JS模块。
JS模块:具有特定功能的js文件,将所有的数据和功能都封装在一个函数内部(私有的),只向外暴露一个包信n个方法的对象或函数,模块的使用者,只需要通过模块暴露的对象调用方法来实现对应的功能。
具体请看下面的例子:
//index.html文件 <script type="text/javascript" src="myModule.js"></script> <script type="text/javascript"> myModule2.doSomething() myModule2.doOtherthing() </script> //myModule.js文件 (function () { var msg = 'Beijing'//私有数据 //操作数据的函数 function doSomething() { console.log('doSomething() '+msg.toUpperCase()) } function doOtherthing () { console.log('doOtherthing() '+msg.toLowerCase()) } //向外暴露对象(给外部使用的两个方法) window.myModule2 = { doSomething: doSomething, doOtherthing: doOtherthing } })()
六、闭包的运用
我们要实现这样的一个需求: 点击某个按钮, 提示"点击的是第n个按钮",此处我们先不用事件代理:
..... <button>测试1</button> <button>测试2</button> <button>测试3</button> <script type="text/javascript"> var btns = document.getElementsByTagName('button') for (var i = 0; i < btns.length; i++) { btns[i].onclick = function () { console.log('第' + (i + 1) + '个') } } </script>
万万没想到，点击任意一个按钮，后台都是弹出“第四个”,这是因为i是全局变量,执行到点击事件时，此时i的值为3。那该如何修改，最简单的是用let声明i
for (let i = 0; i < btns.length; i++) { btns[i].onclick = function () { console.log('第' + (i + 1) + '个') } }
另外我们可以通过闭包的方式来修改:
for (var i = 0; i < btns.length; i++) { (function (j) { btns[j].onclick = function (i) { console.log('第' + (i + 1) + '个') } })(i) }
如果觉得文章对你有些许帮助，欢迎在我的GitHub博客点赞和关注，感激不尽！
ps:文章于2018.11.16重新修改,希望对你们有所收获！
1. "闭包就是跨作用域访问变量。"
【示例一】
|
1
2
3
4
5
6
7
8
9
|
var name = 'wangxi'function user () { // var name = 'wangxi' function getName () { console.log(name) } getName()}user() // wangxi |
在 getName 函数中获取 name，首先在 getName 函数的作用域中查找 name，未找到，进而在 user 函数的作用域中查找，同样未找到，继续向上回溯，发现在全局作用域中存在 name，因此获取 name 值并打印。这里很好理解，即变量都存在在指定的作用域中，如果在当前作用中找不到想要的变量，则通过作用域链向在父作用域中继续查找，直到找到第一个同名的变量为止（或找不到，抛出 ReferenceError 错误）。这是 js 中作用域链的概念，即子作用域可以根据作用域链访问父作用域中的变量，那如果相反呢，在父作用域想访问子作用域中的变量呢？——这就需要通过闭包来实现。
【示例二】
|
1
2
3
4
5
6
7
8
|
function user () { var name = 'wangxi' return function getName () { return name }}var userName = user()()console.log(userName) // wangxi |
分析代码我们知道，name 是存在于 user 函数作用域内的局部变量，正常情况下，在外部作用域（这里是全局）中是无法访问到 name 变量的，但是通过闭包（返回一个包含变量的函数，这里是 getName 函数），可以实现跨作用域访问变量了（外部访问内部）。因此上面的这种说法完整的应该理解为：
闭包就是跨作用域访问变量 —— 内部作用域可以保持对外部作用域中变量的引用从而使得（更）外部作用域可以访问内部作用域中的变量。（还是不理解的话看下一条分析）
2. "闭包：在爷爷的环境中执行了爸爸，爸爸中返回了孙子，本来爸爸被执行完了，爸爸的环境应该被清除掉，但是孙子引用了爸爸的环境，导致爸爸释放不了。这一坨就是闭包。简单来讲，闭包就是一个引用了父环境的对象，并且从父环境中返回到更高层的环境中的一个对象。"
这个怎么理解呢？首先看下方代码：
【示例三】
|
1
2
3
4
5
6
|
function user () { var name = 'wangxi' return name}var userName = user()console.log(userName) // wangxi |
问：这是闭包吗？
答：当然不是。首先要明白闭包是什么。虽然这里形式上看好像也是在全局作用域下访问了 user 函数内的局部变量 name，但是问题是，user 执行完，name 也随之被销毁了，即函数内的局部变量的生命周期仅存在于函数的声明周期内，函数被销毁，函数内的变量也自动被销毁。
但是使用闭包就相反，函数执行完，生命周期结束，但是通过闭包引用的外层作用域内的变量依然存在，并且将一直存在，直到执行闭包的的作用域被销毁，这里的局部变量才会被销毁（如果在全局环境下引用了闭包，则只有在全局环境被销毁，比如程序结束、浏览器关闭等行为时才会销毁闭包引用的作用域）。因此为了避免闭包造成的内存损耗，建议在使用闭包后手动销毁。还是上面示例二的例子，稍作修改：
【示例四】
|
1
2
3
4
5
6
7
8
9
|
function user () { var name = 'wangxi' return function getName () { return name }}var userName = user()() // userName 变量中始终保持着对 name 的引用console.log(userName) // wangxiuserName = null // 销毁闭包，释放内存 |
【为什么 user()() 是两个括号：执行 user() 返回的是 getName 函数，要想获得 name 变量，需要对返回的 getName 函数执行一次，所以是 user()()】
根据观点2，分析一下代码：在全局作用域下创建了 userName 变量（爷爷），保存了对 user 函数最终返回结果的引用（即局部变量 name 的值），执行 user()()（爸爸），返回了 name（孙子）,正常情况下，在执行了 user()() 之后，user 的环境（爸爸）应该被清除掉，但是因为返回的结果 name（孙子）引用了爸爸的环境（因为 name 本来就是存在于 user 的作用域内的），导致 user 的环境无法被释放（会造成内存损耗）。
那么【"闭包就是一个引用了父环境的对象，并且从父环境中返回到更高层的环境中的一个对象。"】如何理解？
我们换个说法：如果一个函数引用了父环境中的对象，并且在这个函数中把这个对象返回到了更高层的环境中，那么，这个函数就是闭包。
还是看上面的例子：
getName 函数中引用了 user（父）环境中的对象（变量 name），并且在函数中把 name 变量返回到了全局环境（更高层的环境）中，因此，getName 就是闭包。
3. "JavaScript中的函数运行在它们被定义的作用域里，而不是它们被执行的作用域里."
这句话对闭包中对变量的引用的理解很有帮助。我们看下面的例子：
|
1
2
3
4
5
6
7
8
9
|
var name = 'Schopenhauer'function getName () { console.log(name)}function myName () { var name = 'wangxi' getName()}myName() // Schopenhauer |
如果执行 myName() 输出的结果和你想象的不一样，你就要再回去看看上面说的这句话了，
JavaScript 中的函数运行在它们被定义的作用域里，而不是它们被执行的作用域里
执行 myName，函数内部执行了 getName，而 getName 是在全局环境下定义的，因此尽管在 myName 中定义了变量 name，对getName 的执行并无影响，getName 中打印的依然是全局作用域下的 name。
我们稍微改一下代码:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
var name = 'Schopenhauer'function getName () { var name = 'Aristotle' var intro = function() { // 这是一个闭包 console.log('I am ' + name) } return intro}function showMyName () { var name = 'wangxi' var myName = getName() myName()}showMyName() // I am Aristotle |
结果和你想象的一样吗？结果留作聪明的你自己分析~
以上就是对 js 中闭包的理解，如果有误，欢迎指正。最后引用一段知乎问题下关于闭包概念的一个回答。
什么是闭包?
简单来说，闭包是指可以访问另一个函数作用域变量的函数，一般是定义在外层函数中的内层函数。
为什么需要闭包？
局部变量无法共享和长久的保存，而全局变量可能造成变量污染，所以我们希望有一种机制既可以长久的保存变量又不会造成全局污染。
特点
- 占用更多内存
- 不容易被释放
何时使用？
变量既想反复使用，又想避免全局污染
如何使用？
- 定义外层函数，封装被保护的局部变量。
- 定义内层函数，执行对外部函数变量的操作。
- 外层函数返回内层函数的对象，并且外层函数被调用，结果保存在一个全局的变量中。
好了，以上所述是小编给大家介绍的js中的闭包，希望对大家有所帮助！
学习Javascript闭包（Closure）
闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。
下面就是我的学习笔记，对于Javascript初学者应该是很有用的。
一、变量的作用域
要理解闭包，首先必须理解Javascript特殊的变量作用域。
变量的作用域无非就是两种：全局变量和局部变量。
Javascript语言的特殊之处，就在于函数内部可以直接读取全局变量。
var n=999;
function f1(){
alert(n);
}f1(); // 999
另一方面，在函数外部自然无法读取函数内的局部变量。
function f1(){
var n=999;
}alert(n); // error
这里有一个地方需要注意，函数内部声明变量的时候，一定要使用var命令。如果不用的话，你实际上声明了一个全局变量！
function f1(){
n=999;
}f1();
alert(n); // 999
二、如何从外部读取局部变量？
出于种种原因，我们有时候需要得到函数内的局部变量。但是，前面已经说过了，正常情况下，这是办不到的，只有通过变通方法才能实现。
那就是在函数的内部，再定义一个函数。
function f1(){
var n=999;
function f2(){
alert(n); // 999
}}
在上面的代码中，函数f2就被包括在函数f1内部，这时f1内部的所有局部变量，对f2都是可见的。但是反过来就不行，f2内部的局部变量，对f1就是不可见的。这就是Javascript语言特有的"链式作用域"结构（chain scope），子对象会一级一级地向上寻找所有父对象的变量。所以，父对象的所有变量，对子对象都是可见的，反之则不成立。
既然f2可以读取f1中的局部变量，那么只要把f2作为返回值，我们不就可以在f1外部读取它的内部变量了吗！
function f1(){
var n=999;
function f2(){
alert(n);
}return f2;
}
var result=f1();
result(); // 999
三、闭包的概念
上一节代码中的f2函数，就是闭包。
各种专业文献上的"闭包"（closure）定义非常抽象，很难看懂。我的理解是，闭包就是能够读取其他函数内部变量的函数。
由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成"定义在一个函数内部的函数"。
所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
四、闭包的用途
闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。
怎么来理解这句话呢？请看下面的代码。
function f1(){
var n=999;
nAdd=function(){n+=1}
function f2(){
alert(n);
}return f2;
}
var result=f1();
result(); // 999
nAdd();
result(); // 1000
在这段代码中，result实际上就是闭包f2函数。它一共运行了两次，第一次的值是999，第二次的值是1000。这证明了，函数f1中的局部变量n一直保存在内存中，并没有在f1调用后被自动清除。
为什么会这样呢？原因就在于f1是f2的父函数，而f2被赋给了一个全局变量，这导致f2始终在内存中，而f2的存在依赖于f1，因此f1也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection）回收。
这段代码中另一个值得注意的地方，就是"nAdd=function(){n+=1}"这一行，首先在nAdd前面没有使用var关键字，因此nAdd是一个全局变量，而不是局部变量。其次，nAdd的值是一个匿名函数（anonymous function），而这个匿名函数本身也是一个闭包，所以nAdd相当于是一个setter，可以在函数外部对函数内部的局部变量进行操作。
五、使用闭包的注意点
1）由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。
2）闭包会在父函数外部，改变父函数内部变量的值。所以，如果你把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。
六、思考题
如果你能理解下面两段代码的运行结果，应该就算理解闭包的运行机制了。
代码片段一。
var name = "The Window";
var object = {
name : "My Object",getNameFunc : function(){
return function(){
return this.name;
};}
};
alert(object.getNameFunc()());
代码片段二。
var name = "The Window";
var object = {
name : "My Object",getNameFunc : function(){
var that = this;
return function(){
return that.name;
};}
};
alert(object.getNameFunc()());
