一、什么是闭包？
如果这个函数能够访问其他函数作用域中的变量，那么这个函数就叫做闭包。
换句话说，只要在一个函数中再定义一个函数，这个内部函数就是一个闭包。其实就是函数嵌套函数，主要是为了造出一个局部变量。也是一种数据封装的手段。
其实函数的作用域是独立的、封闭的，外部的执行环境是访问不了的，但是闭包具有这个能力和权限。所以有作用域的地方就有闭包。其实闭包就是JS 函数作用域的副产品。
闭包的这种特性有助于我们在JavaScript这门非面向对象的语言中实现面向对象的一些特性。“闭”的意思不是封闭内部状态，而是封闭外部状态，当外部状态的scope失效时，还有一份留在内部状态里。
闭包的表现形式？
第一，闭包是一个函数，而且存在于另一个函数中；
第二，闭包可以访问到父级函数的变量，且该变量不会被销毁。
function person () {
var name = '有雨';
function cat () {
console.log(name);
}
return cat;
}
var per = person(); // per就是return后的结果，即cat函数；
per(); // 有雨 per()就相当于cat()
per(); // 有雨 同上，而且变量name没有销毁，一直存在内存中，供函数cat调用。
per(); // 有雨
二、闭包的原理
闭包的实现原理，其实就是利用了作用域链的特性，作用域链就是在当前执行环境下访问某个变量时，如果不存在就一直向外层寻找，最终寻找到最外层也就是全局作用域，这样就形成了一个链条。
例如：
var age = 18;
function cat () {
age++;
console.log(age); // 19 cat函数内输出age，该作用域没有，向外层寻找，结果找到了，输出19.
}
cat(); // 19
cat(); // 20
cat(); // 21
如果该程序还有其他函数，也需要用到age的值，那使用age就会受到影响，而且全局变量还容易被人修改，比较不安全，这就是全局变量容易被污染的原因，所以为了解决变量污染问题，就把变量封装到函数内，让它成为局部变量。
function person () {
var age = 18;
function cat () { // age变量和cat函数就组成了一个[闭包]
age++;
console.log(age);
}
return cat(); // 如果不 return，你就无法使用这个闭包，主要是为了让外面可以访问到这个cat函数。把 return cat改成 window.cat = cat 也是一样的
}
person(); // 19 这里的person是返回的cat函数执行的结果
person(); // 19
这里又有个问题，每次调用函数person，进入该作用域，变量age就要被重新赋值为18，所有cat()的值一直是19，所以稍作调整：
var per = person; // per相当于函数cat
per(); // 19. 即cat()，这样每次调用不再经过age的初始值，而是去执行自增函数，这样就可以一直增加了
per(); // 20
per(); // 21
三、闭包的作用
- 隐藏变量，可以避免使用全部变量，防止全局变量污染；
- 暴露一个访问器，让外部函数可以读取函数内部的变量；
- 封装私有变量，提供一些暴露的接口；
- 局部变量会常驻在内存中；
缺点：
- 导致变量不会被垃圾回收机制回收，造成内存消耗；
- 不恰当的使用闭包可能会造成内存泄漏的问题；
JS垃圾回收机制
JS规定在一个函数作用域内，程序执行完以后变量就会被销毁，这样可以节省内存。
使用闭包时，按照作用域的特点，闭包函数外面的变量不会被销毁，因为闭包的作用域中存在外层函数的变量，这个变量会一直被内层函数的作用域调用，所以一直存在，不会被内存回收。如果闭包使用过多就会导致内存消耗。
详见第七节内容。
四、闭包的创建
在知乎看到一个很有意思的解释，这里复述一下：
我叫独孤求败，在一个山洞里，里面有世界上最好的剑法，还有最好的武器，我学习了里面的剑法，拿走了最好的剑，离开了这里。我来到这个江湖，快意恩仇，但是从来没有人知道我这把剑的来历和我这一身的武功。那我和山洞整体就是一个闭包，而我是山洞里唯一一个可以与外界交汇的地方，这山洞的一切对外人而言就像不存在一样，只有我才知道这里面的宝藏。所以我就相当于return的那个函数。
五、内存泄漏？闭包滥用？
内存泄露是指你用不到（访问不到）的变量，依然占据着内存空间，不能被再次利用起来，没有及时释放。
因为 IE。IE 有 bug，IE 在我们使用完闭包之后，依然回收不了闭包里面引用的变量。这是 IE 的问题，不是闭包的问题。
什么情况会引起内存泄漏？
- 意外的全局变量引起的内存泄漏
原因：全局变量不会被垃圾回收机制回收。
解决：使用严格模式避免。use strict - 闭包引起的内存泄漏
原因：闭包可以维持函数内局部变量内存，使其得不到释放。
解决：将事件处理函数定义在外部，解除闭包，或者在定义事件处理函数的外部函数中，删除对DOM的引用。 - 没有清理DOM元素引用
原因：虽然别的地方删除了，但是对象对DOM的引用还在
解决：手动删除，置为null。 - 被遗忘的定时器或回调
原因：定时器中有DOM的引用，即使DOM删除了，但定时器还在，所以内存中还是有这个DOM。
解决：手动删除定时器和DOM。 - 子元素存在引用引起的内存泄漏
原因：div中的ul li 得到这个div，会间接引用某个得到的li，那么此时因为div间接引用li，即使li被清空，但是内存还在，并且只要li不被删除，它的父元素都不会被删除。
解决：手动删除清空。 - console保存大量数据在内存中
原因：过多的console，比如定时器的console会导致浏览器卡死。
解决：合理利用console，线上项目尽量少的使用console。
怎么观察内存泄露呢？
如果连续五次垃圾回收之后，内存占用一次比一次大，就有内存泄漏。这就要求实时查看内存占用。一般是堆区内存泄漏，栈区不会泄漏。
如何避免内存泄露呢？
1、减少不必要的全局变量，使用严格模式避免意外创建全局变量。
2、在你使用完数据后，及时解除引用(闭包中的变量，dom引用，定时器清除)。
3、组织好你的逻辑，避免死循环等造成浏览器卡顿，崩溃的问题。
内存分配
JS有两种类型的值：简单类型（string、number、boolean、null、undefined、symbol）和复杂类型（object）。
简单类型又称基本类型，按值访问；复杂类型又称引用类型，按引用访问。
1、基本类型存储在栈stack中（先进后出）
var a = 1;
var b = "hello";
var c = true;
var d = null;
当复制基本类型时，栈内存会开辟一个新的内存给b，只需要把a的值赋值给变量b，变量b得到的只是变量a所指示内存上的内容。执行b=3之后，这个变量b又变成3，但是a仍然是1，也就是说a和b是互相独立的、互不影响的，这就是按值传递。
var a = 1;
var b = a; // a赋值给b
b = 3;
console.log(a); // 1
console.log(b); // 3
2、引用类型存储在堆heap中
var a = 1;
var b = hello;
var c = {name: 'zhou', age: 18};
var d = c; // d和c指向同一个内存地址
d.name = 'wang'; // 修改name的值
console.log(c.name); // wang （d和c会互相影响）
当复制引用类型时，其实d复制的是c的引用地址，它们引用同一个地址，改变其中一个，另一个也跟着改变。如下图，对于引用类型，名存在于栈内存中，但值存在于堆内存中，栈内存会提供一个引用的地址指向堆内存中的值。
六、闭包的应用
1、实现变量a自增
var inc = (function () { // 该函数体中的语句将被立即执行
var count = 0; // 局部变量初始化
return function () { // 返回一个内嵌的闭包函数引用
return ++count; // 当外部函数return后，这里的count不再是外部函数的局部变量。
}
})(); //
inc(); // count: 1
inc(); // count: 2
或者
function Add2 () {
var a = 3;
return function () {
a++;
return a;
}
}
console.log(Add2()()) // 4
console.log(Add2()()) // 4
var add = Add2()
console.log(add()) // 4
console.log(add()) // 5
console.log(add()) // 6
2、闭包访问外层函数变量的特点
若闭包在外层函数执行结束后执行，那么它只能获取到外层函数中所有变量的最终状态。
function father () {
var array = [];
for (var i = 0; i < 10; i++) {
array[i] = function () {
return i;
}
}
return array;
}
father函数执行后会返回一个包含闭包的数组，每个闭包都会返回。由于这里的闭包调用时，外层函数早已经执行完了，外层函数变量对象中 i 的值已经变成了9，此时不管执行array中的哪个闭包，返回的结果都是9。但是，如果在闭包外层函数执行过程中立即执行闭包，那么结果就不一样了，如下：
function father () {
var array = [];
for (var i = 0; i < 10; i++) {
array[i] = (function () {
return i;
})();
}
return array;
}
此时闭包在外层函数执行时就立即执行，在那时，闭包中的值就是外层函数当前的值，因此返回的array中存储的值就是0-9。
但是，例1 中array存放的是闭包，而例2 中array存放的是闭包执行的结果，那么若想让array存储闭包，还需要进行改造，如下：
function father () {
var array = [];
for (var i = 0 ; i < 10; i++) {
array[i] = (function () {
var cur = i;
return function () {
return cur;
}
})();
}
return array;
}
我们让立即执行的闭包再返回一个闭包，并且将for循环中的值赋给立即执行函数的局部变量，此时array存储的将是闭包，并且每个闭包都有正确的值。
如果一个函数内部有闭包存在，那么函数执行结束之后不会释放自己的变量对象，只有当闭包执行结束后才会释放，因此他们具有不同的垃圾回收机制。
七、JS垃圾回收机制
1、什么是垃圾？
一般来说没有被引用的或者用不到的变量对象就是垃圾，就要被清除，如果几个对象互相引用形成一个环，但根访问不到它们，这几个对象也是垃圾，也要被清除。JS 具有自动垃圾回收机制，垃圾收集器会按照固定的时间间隔，周期性的找出不再继续使用的变量，然后释放其内存。
注意：这里不再使用的变量也就是生命周期结束的变量，是局部变量，局部变量只在函数执行的过程中存在，当函数运行结束，没有其他引用，那么该变量就会被标记回收。而全局变量的生命周期直到浏览器卸载页面才会结束，也就是说全局变量不会被当成垃圾回收。
2、垃圾回收方法
a. 引用计数（reference counting）
引用计数，顾名思义就是一个对象是否有指向它的引用。语言引擎有一张引用表，保存了内存中所有的资源，通常是各种值的引用次数。如果一个值的引用次数是0，就表示这个值不再用到了，那么就可以将这块内存释放。
工作原理：
跟踪记录每个值被引用的次数。
工作流程：
① 声明了一个变量并将一个引用类型的值赋给了这个变量，这个引用类型值的引用次数就是1；
② 同一个值又被赋给了另一个变量，这个引用类型值的引用次数加1；
③ 当包含这个引用类型值的变量又被赋值给另一个值了，那么这个引用类型值的次数减1；
④ 当引用次数变成0，说明没办法访问这个值了；
⑤ 当垃圾回收器下一次运行时，它就会释放引用次数为0的值的内存。
如果一个值不再需要了，但是引用次数却不为0，垃圾回收机制无法释放这块内存，从而导致内存泄漏。
const arr = [1,2,3,4];
console.log('hello world')
上面代码中，数组[1,2,3,4]是一个值，会占用内存，变量arr是仅有的对这个值的引用，因此引用次数为1，尽管后面的代码没有用到arr，它还是会持续占用内存。
如果增加一行代码，解除arr对[1,2,3,4]的引用，那么这块内存就可以被垃圾回收机制释放了。
let arr = [1,2,3,4];
console.log('hello world');
arr = null;
上面代码中，arr 重置为 null，就解除了对[1,2,3,4]的引用，引用次数变成0，内存就可以释放出来了。
因此，并不是说有了垃圾回收机制，程序员就轻松了，还需要关注内存占用问题，那些很占空间的值，一旦不再使用，必须检查是否还存在对它的引用，如果是的话，就必须手动解除引用。
缺点
引用计数有个致命缺点就是循环引用。当两个对象相互引用，尽管他们不再使用，但是垃圾回收器不会进行回收，最终会导致内存泄漏。
function cycle () {
var o1 = {};
var o2 = {};
o1.a = o2;
o2.a = o1;
return "cycle reference"
}
cycle();
// 手动切断链接
o1.a = null;
o2.a = null;
这两个对象的引用次数都是2，cycle函数执行完成之后，对象o1和o2实际上已经不再需要了，但根据引用计数的原则，他们之间的相互引用依然存在，因此这部分内存不会被回收。所以现代浏览器不再使用这个算法。但是IE依旧使用，
var div = document.createElement('div');
div.onClick = function () {
console.log('click');
}
上面的写法很常见，但是上面的例子就是一个循环引用。
变量div有事件处理函数的引用，同时事件处理函数也有div的引用，因为div变量可在函数内被访问，所以循环引用就出现了。
因为IE中的BOM、DOM的实现使用了COM，而COM对象使用的垃圾收集机制是引用计数策略。所以会存在循环引用的问题。
解决：手工断开js对象和DOM之间的链接，赋值为null。IE9把DOM和BOM转换成真正的JS对象了，所以避免了这个问题。
b. 标记清除（常用）
当一块内存中的数据能够被访问时，垃圾回收器就认为该数据能够被获得，不能够被获得的数据，就会被打上标记，并回收内存空间，这种方法叫做标记清除法。（即从根部（在JS中就是全局对象）出发定时扫描内存中的对象，凡是能从根部到达的对象，保留。那些从根部出发无法触及到的对象被标记为不再使用，稍后进行回收。）
工作原理：
当变量进入环境时，将这个变量标记为“进入环境”，当这个变量离开环境时，标记为“离开环境”，并且回收该内存。
工作流程：
① 垃圾回收器，在运行的时候会给存储在内存中的所有变量加上标记；
② 去掉环境中的变量以及被环境中的变量引用的变量标记；
③ 再被加上标记的会被视为准备删除的变量；
④ 垃圾回收器完成内存清除工作，销毁那些带标记的值并回收他们所占的内存空间。
