一、引子
闭包（closure）是 Javascript 语言的一个难点，面试时常被问及，也是它的特色，很多高级利用都要依附闭包实现。本文尽可能用简略易懂的话，讲清楚闭包的概念、造成条件及其常见的面试题。
咱们先来看一个例子：
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 () {console.log('第' + (j + 1) + '个')
}
})(i)
}