什么是闭包？———>是一个函数，一个可以访问其他函数内部数据的函数。
栗子一：
function foo() {
var a = 1;
}
function fn() {
console.log(a);//报错,因为这里是无法访问到a的
}
function foo() {
var a = 1;
function fn() {
console.log(a);//这样是可以访问到a的
}
return fn;//fn就是闭包，其在foo内部调用没有意义，所以将其返回，交由外部来决定调用时机，更具开发意义，当执行外部函数时，才会创建闭包fn
}
一、闭包基本结构：
1.定义外层函数；
2.定义内部函数；
3.内层函数引用外层函数定义的数据；
4.要将内层函数作为外层函数的返回值；
function outer() {
var data = {name: "xiaoming”};//外层函数的内部数据会一直缓存在内存中
function inner() {
return data;
}
return inner;
}
var closure1 = outer();//拿到闭包之后就可以决定什么时候执行它；
console.log(closure1());
var closure2 = outer();
console.log(closure2 == closure1);//false,由于调用了两次outer函数，从而创建了两个data对象，因此两个闭包访问到的数据（data）在内存中的地址是不同的；
var d1 = closure1();
Var d2 = closure1();
Console.log(d1 == d2);//true
一个闭包是共享一个数据的，两个闭包则是两个数据，所以不必创建两个闭包（即执行两次外部函数）；
闭包实际应用： 点击每个li打印出每个li对应的数字
<ul>
<li>0</li>
<li>1</li>
<li>2</li>
<li>3</li>
<li>4</li>
</ul>
<script>
var lists = document.getElementsByTagName("li");
var i = 0,
l = lists.length;
for (; i<l; i++) {
lists[i].onclick = function() {//给每个li绑定了点击事件
console.log(i);//结果都打印5,因为当点击li的时候，i已经变成了5
}
}
</script>
运用闭包来解决问题：
var lists = document.getElementsByTagName("li");
var i = 0,
l = lists.length;
for (; i<l; i++) {
lists[i].onclick = (function(i) {//2.接收参数到外层函数内部，并作为内部数据缓存在内存中
function fn() {
console.log(i)；//3.这里的i为外层函数的内部数据，分别为0，1，2，3，4
}
return fn;//4.返回到外部作为点击事件的处理函数，当发生点击事件时，触发这个闭包的执行，那时打印出来的i为外层函数缓存的i值
})(i);//1.自执行函数，将全局变量i依次传入外层函数中
}
iife（立即执行函数表达式）:
(Function(){})();
!function(){}();
+function(){}();
二、闭包的作用
1.避免全局污染
var $ = function() {};//定义的事全局变量$
//但如果在这之前引入了一个jquery.js，那么jquery的$函数就会被这个全局变量$覆盖
在日常开发中，这种事情会很常见，因为你不能保证其他开发人员会定义怎样的变量，这时一个页面先引入了的js文件中的变量就有可能被后面的js文件中定义的同名的全局变量覆盖；
另外，全局变量生命周期是随着页面的存在而存在的，页面在，变量就会一直占用内存，耗费性能，所以不推荐过多的使用全局变量；
function outer() {//外层函数中的$和attr其实就相当于全局变量，只要闭包存在，这些变量就会一直在
var $ = function() {};
var attr = 10;
return {//这里面的$和attr不会被任何其他的全局变量污染
$ : $,
getAttr : function() {
return attr;
}
}
}
var query = outer();
query.$(“divs”);
console.log(query.getAttr);
以上栗子中将$和attr变量放在一个外层函数里面作为内部数据，而将闭包（指$和getAttr两个方法）返回并赋值给一个全局变量query，当全局变量较多时就能够极大的降低全局污染的概率。
2.缓存数据
1)可用全局变量做缓存———>生命周期太长耗费性能
2)可用cookie\localStorage等做缓存——>io流没有在内存中访问速度快
3)用闭包来做缓存
举个栗子：求fibonancci数列第n项值
function fib(n) {
if (n < 1) {
throw new Error("value not increct");
}
if (n == 1 || n == 2) {
return 1;
} else {
return fib(n - 1) + fib(n - 2);
}
}
递归方式求Fib(6)值的过程图解：
这里面有太多的重复计算，当要求的数值很大时，性能就会特别低；
用闭包来进行优化：
function createFib() {
var cache = [, 1, 1];//存储计算结果，计算过的结果得以缓存在内存中以便下次直接使用
return function(n) {//闭包这个函数的作用是求得地n项的值，闭包函数可拿到缓存中已经计算过结果的那些项的值；
var res = cache[n];//如果缓存中有这一项，那么直接用
if (!res) {//若没有这一项的值，就要重新计算
res = cache[n] = fib(n - 1) + fib(n - 2);//第n项的值为他的前两项值的和，依旧用递归，这里不同的是，计算过的值不用再重新计算，而是直接拿缓存中的结果，另外本次计算完成后，也要将结果存储到cache中以便下次使用，并且将值赋给res变量用来返回；
}
return res;
};
}
var fib = createFib();//需要递归的是fib这个闭包而不是外层函数createFib，因为闭包才是真正的执行求第n项值的功能函数，而外层函数的作用是用内部数据来做缓存；
console.log(fib(50));//大大提高计算效率
闭包的方式计算fib(6)值的过程如下：
3、高阶函数
满足以下条件之一就是高阶函数
- 函数类型作为参数（比如es5中forEach, map,filter,回调函数）
- 返回函数(闭包)
举个栗子：求员工工资（底薪+提成），普通员工底薪1000，提成每个人都不一样，经理底薪2000，提成每个经理都不同；
function calSalary(base, ext) {
var base = base * 10 + 20;//每次计算都要重复
return base + ext;
}
var s1 = calSalary(1000, 100);
var s2 = calSalary(1000, 200);
:
:
var p1 = calSalary(2000, 100);
var p2 = calSalary(2000, 300);
像这种有基数的计算，可以用闭包来进行优化：
function calSalary(base) {
var base = base * 10 + 20;//一次计算后作为缓存
return function(ext) {
return base + ext;//这里直接拿缓存中的base，省去了很多重复计算
}
}
var s = calSalary(1000);//拿到闭包
var s1 = s(500);//每次只执行闭包
var s2 = s(1000);
var p = calSalary(2000);//创建另一个闭包，因为共享数据不同
var p1 = p(500);//同样每次只执行闭包
var p2 = p(500);
4、回调函数传参:
栗子：给定时器的回调函数传参，实现div1秒后背景变成红色;
setTimeout((function(color){//立即执行函数，接收color参数，缓存在内存中
var div = document.getElementById("div");
return function() {//返回一个函数作为延时回调函数，1秒后执行
div.style.background = color;
}
})('red'), 1000)
扩展:
- setInterval和setTimeout第三个参数可向函数中传参：setTimeout(function(){}, 200, 10);
- bind方法可实现向回调函数传参
setTimeout(function(color){
var div = document.getElementById("div”);
div.style.background = color;
}.bind(null, 'red'), 1000)