一、什么是闭包？

如果这个函数能够访问其他函数作用域中的变量，那么 这个函数 就叫做闭包。

换句话说，只要在一个函数中再定义一个函数，这个内部函数就是一个闭包。其实就是函数嵌套函数，主要是为了造出一个局部变量。也是一种数据封装的手段。

其实函数的作用域是独立的、封闭的，外部的执行环境是访问不了的，但是闭包具有这个能力和权限。所以有作用域的地方就有闭包。其实闭包就是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的引用地址，它们引用同一个地址，改变其中一个，另一个也跟着改变。如下图，对于引用类型，名存在于栈内存中，但值存在于堆内存中，栈内存会提供一个引用的地址指向堆内存中的值。
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 () {
  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中就是全局对象）出发定时扫描内存中的对象，凡是能从根部到达的对象，保留。那些从根部出发无法触及到的对象被标记为不再使用，稍后进行回收。）
工作原理：
当变量进入环境时，将这个变量标记为“进入环境”，当这个变量离开环境时，标记为“离开环境”，并且回收该内存。