闭包：由许多被引用变量和包含这些变量的环境组成。
产生闭包的条件：
1.函数嵌套
2.内部函数引用外部函数的变量或者函数
3.在外部执行外部函数
在执行外部函数的时候，嵌套的内部函数也引用了嵌套的外部函数的变量或者函数，就会产生闭包。
闭包特点
1.一般函数执行完后，函数内部声明的局部变量都会被销毁。而存在于闭包中的局部变量不会被立马销毁，存在一段生命周期。
2.外部函数可以对函数内部局部变量进行操作
3.闭包容易造成内存泄露，比如产生了某个闭包，在函数执行完毕后，局部变量没有释放，会一直占用内存？，容易造成内存泄露。所以，不能滥用闭包。当我们使用完闭包后，应该将引用变量置为null。
闭包的常用方式
1.将函数作为另一个函数的返回值
function test(){
let a = 10
return function(){
a++
console.log(a)
}
}
let t = test()
t()
t()
//释放内存
t = null
上述代码中，test()执行后返回的是函数t，函数t第一次执行的时候，变量a自增，所以a等于11，这毫无疑问。那函数t第二次执行的时候，不应该还是先找到外部的变量a，再进行自增，所以a还是等于11吗？
这里就需要知道，第二次执行函数t的时候，找到的还是test()内部定义的变量a，只不过这个a的值在经过上一次函数t的调用后发生了变化，所以第二次执行函数t的时候，变量a的值是基于上一次的结果进行变化的。有人也许有其它疑惑，函数执行完毕后。函数内部的局部变量不是会被销毁吗？但是，变量被销毁的前提是这个变量不再被引用了，而上面的例子中，变量a在第二次执行函数t的时候还被引用，所以不会被销毁。
2.将函数作为另一个函数的实参
let test3 = (fn) =>{
return fn()
}
let test1 = () =>{
let a = 10
let test2 = () =>{
return a
}
return test3(test2)
}
console.log(test1())
3.利用闭包定义一个包含很多私有变量、私有函数的公有函数，这个公有函数可以被当做单独的一个js模块使用，模块的内部封装了许多的私有属性和方法，模块只向外暴露一个私有属性、方法的对象，在其它地方引入此模块，就可以根据暴露的对象使用模块中的私有属性和方法。
var counter = (function(){
var privateCounter = 0; //私有变量
function change(val){
privateCounter += val;
return privateCounter
}
return { //变量属性和方法
increment:function(num){
return change(num);
},
decrement:function(num){
return change(num);
},
value:function(){
return privateCounter;
}
};
})();
console.log(counter.value());//0
console.log(counter.increment(5));//5
console.log(counter.increment(3));//8
4.给setTimeout()传参
function fn(a){
console.log(a*2)
}
setTimeout(fn(2),1000)
5.假设有这样一个功能：点击某个按钮，显示这是第几个按钮。
<button class='btn'>按钮1</button>
<button class='btn'>按钮2</button>
<button class='btn'>按钮3</button>
var btns = document.querySelectorAll('.btn')
var length = btns.length
for(var i = 0; i < length;i++){
btns[i].onclick = function(){
console.log(`这是第${i+1}个按钮`)
}
}
//这种写法导致不管点击的是哪个按钮，得到的结果都是第3个按钮
//因为每次执行点击事件，都会去查找i，而这里的i属于全局变量，并且在for循环结束后，i的值就已经确定是3了。所以每次去找这个i，都是已经为3的i。
//早期修改方法
var btns = document.querySelectorAll('.btn')
var length = btns.length
for(var i = 0; i < length;i++){
btn[i].index = i //给每个按钮添加一个属性记录i值，这个i属于每个按钮本身
btns[i].onclick = function(){
console.log(`这是第${this.index+1}个按钮`)
}
}
//也可以利用闭包
var btns = document.querySelectorAll('.btn')
var length = btns.length
for(var i = 0; i < length;i++){
(function(j){
btns[j].onclick = function(){
console.log(`这是第${j+1}个按钮`)
}
})(i)
}
//也可以利用let关键字
var btns = document.querySelectorAll('.btn')
var length = btns.length
for(let i = 0; i < length;i++){
btns[i].onclick = function(){
console.log(`这是第${i+1}个按钮`)
}
}
闭包面试题
function fnnn(){
var arr = [];
for(var i = 0;i < 5;i ++){
arr[i] = function(){
return i;
}
}
return arr;
}
var list = fnnn();
for(var i = 0,len = list.length;i < len ; i ++){
console.log(list[i]());//5 5 5 5 5
}
<body>
<button id="add">加1</button>
<span id="span">10</span>
</body>
<script>
//第一种写法
var a = 10;
add.onclick = function (){
a++;
span.innerHTML = a;
}
//第二种写法
add.onclick = function (){
var a = 10;
a++;
span.innerHTML = a;
}
</script>
上面第一种写法，每次点击按钮都会加1，而第二种写法每次得到的结果都是一样的。这里我们就需要了解一个知识点：局部变量在没有被其它对象引用的时候就会被销毁掉。第一种写法下，定义的a是全局变量，全局变量只有在页面关闭或者浏览器关闭的时候才会被销毁，所以，每次点击，都是在原来的基础上加1，不断递增。而对于第二种写法，每次点击，执行完回调函数后，局部变量就被销毁，再次点击的时候，重新定义了变量a，所以每次点击的结果都一样。
把上面的例子引用到闭包来，在闭包中，嵌套的内部函数使用外部函数的局部变量，就类似于上面举的例子。外部函数执行完，但是局部变量不会销毁，如果创建的闭包很多，那么就有许多变量不会被销毁，一直保存在内存中，很有可能造成内存泄露。
学习闭包的过程中，发现这样一种情况：还不知道什么原因。
function fun(num){
console.log(num)
}
let obj = {
fix:function(num){
return fun(num)
}
}
obj.fix(5)
//但是下面这种写法就不行
let obj1 = {
fix:function(num){
return function(num){//为什么返回匿名函数就没有输出结果呢？
console.log(num)
}
}
}
obj1.fix(5)//无结果
