JavaScript的函数闭包详细解释

闭包的理解

如何产生闭包

当一个嵌套的内部(子)函数引用了嵌套的外部(父)函数的变量(函数)时, 就产生了闭包

function fn1 () {
  var a = 3
  function fn2 () {
    console.log(a)
  }
}
fn1()

产生闭包的条件

函数嵌套；内部函数引用了外部函数的数据(变量/函数)，并且执行函数

闭包到底是什么

理解一: 闭包是嵌套的内部函数(绝大部分人)

理解二: 包含被引用变量(函数)的对象(极少数人)

注意: 闭包存在于嵌套的内部函数中

创建闭包的常见的方式

就是在一个函数内部创建另一个函数，通过另一个函数访问这个函数的局部变量。

//通过闭包可以返回局部变量
function box() {
  var user = 'Lee';
  return function () { //通过匿名函数返回 box()局部变量
    return user;
  };
}
alert(box()()); //通过box()()来直接调用匿名函数返回值

var b = box();
alert(b()); //另一种调用匿名函数返回值

常见的闭包

将函数作为另一个函数的返回值

function fn1() {
  var a = 2
  function fn2() {
    a++
    console.log(a)
  }
  return fn2
}
var f = fn1() // f就是fn2这个函数
f() // 3，当调用fn2这个函数的时候，执行到var a = 2的时候闭包就已经产生了，因为函数提前声明了
f() // 4，执行这里的时候直接执行了内部函数中的a++, 因为只产生了一个闭包

将函数作为实参传递给另一个函数调用

function showMsgDelay(msg, time) {
  setTimeout(function () {
    console.log(msg) // 只有msg才是这个引入的变量
  }, time)
}
showMsgDelay('hello', 1000)

闭包的优点就是缺点（闭包的作用）

就是可以把局部变量驻留在内存中（延长了局部变量的生命周期），可以避免使用全局变量。(全局变量污染导致应用程序不可预测性，每个模块都可调用必将引来灾难，所以推荐使用私有的，封装的局部变量)。

让函数外部可以操作(读写)到函数内部的数据(变量/函数)

//通过全局变量来累加
var age = 100;                 //全局变量
function box() {
  age ++;                 //模块级可以调用全局变量，进行累加
}
box();                         //执行函数，累加了
alert(age);                 //输出全局变量,结果是101
box();
alert(age);                    //结果是102，累加了

//通过局部变量无法实现累加
function box() {
  var age = 100;
  age ++;                     //累加
  return age;
}
alert(box()); //101
alert(box()); //101，无法实现，因为又被初始化了

//通过闭包可以实现局部变量的累加
function box() {
  var age = 100;
  return function () {
    age ++;
    return age;
  }
}
var b = box(); //获得函数 当不用的时候将b解除引用b=null，等待垃圾回收
alert(b()); //调用匿名函数，间接操作了外部函数中的局部变量
alert(b()); //第二次调用匿名函数，实现累加

由于闭包里作用域返回的局部变量资源不会被立刻销毁回收，所以可能会占用更多的内存。过度使用闭包会导致性能下降，建议在非常有必要的时候才使用闭包。

在使用完闭包后将b解除引用，这样就不会一直占据着内存了

闭包的生命周期

产生: 在嵌套内部函数定义执行完时就产生了(不是在调用)

死亡: 在嵌套的内部函数成为垃圾对象时

function fun1() {
  //此处闭包已经产生（函数提升，内部函数对象已经创建了）
  var a = 3;
  function fun2() {
    a++;
    console.log(a);
  }
  return fun2;
}
var f = fun1();

f();
f();
f = null //此时闭包对象死亡（包含闭包的函数对象成为了垃圾）

闭包的问题：循环里包含匿名函数

作用域链的机制导致一个问题，在循环中里的匿名函数取得的任何变量都是最后一个值。

 //循环里包含匿名函数
    function box() {
        var arr = [];
        for (var i = 0; i < 5; i++) {
            arr[i] = function () {
                return i;
            };
        }
        return arr;
    }
    
    var b = box(); //调用这个函数，返回一个数组，数组中的元素是循环里的匿名函数本身
    alert(b.length); //得到的数组长度结果是5
    
    for (var i = 0; i < b.length; i++) {
        alert(b[i]()); //输出每个函数的值，都是最后一个值（即循环里执行到最后一步的i++，是5）
    }

上面的例子输出的结果都是 5，也就是循环后得到的最大的 i 值。

因为 b[i]调用的是匿名函数，匿名函数并没有自我执行，等到调用的时候，box()已执行完毕返回一个数组了，循环也已经结束了所以，i 早已变成 5，最终的结果就是 5 个 5。

改进上面的列子

改1：循环里包含匿名函数-改 1，自我执行匿名函数

　　function box() {
        var arr = [];
        for (var i = 0; i < 5; i++) {
            arr[i] = (function (num) {                 //通过自我及时执行
                return num;
            })(i);                                         //并且传参
        }
        return arr;
    }
    var b = box();//返回的是数组，数组里的元素不是函数了
    
    for (var i = 0; i < b.length; i++) {
        alert(b[i]);                                     //这里返回的是数组，直接打印即可
    }

我们让匿名函数进行自我执行，导致最终返回给 a[i]的是数组而不是函数了。最终导致 b[0]-b[4]中保留了 0,1,2,3,4 的值。

改进2：循环里包含匿名函数-改 2，匿名函数下再做个匿名函数

　　function box() {
        var arr = [];
        for (var i = 0; i < 5; i++) {
            arr[i] = (function (num) {
                //num其实在这里
                return function () {             //直接返回值，改 2 变成返回函数
                    return num;                 //原理和改 1 一样
                }
            })(i);
        }
        return arr;
    }
    
    var b = box();
    alert(b);
    for (var i = 0; i < b.length; i++) {
        alert(b[i]());                     //这里通过 b[i]()函数调用即可
    }
    //box()函数已经执行完了，为什么还能是0,1,2,3,4呢？  因为闭包可以将变量驻留在内存中和上述的累加是一样的道理

改 1 和改 2 中，我们通过匿名函数自我执行，立即把结果赋值给 a[i]。每一个 i，是调用方通过按值传递的，所以最终返回的都是指定的递增的 i。而不是 box()函数里的 i。

闭包中的this使用问题

在闭包中使用 this 对象也可能会导致一些问题，this 对象是在运行时基于函数的执行环境绑定的，如果 this 在全局范围就是 window，如果在对象内部就指向这个对象。

而闭包却在运行时指向 window 的，因为闭包并不属于这个对象的属性或方法。

　　var user = 'The Window';
    var obj = {
        user : 'The Object',
        getUserFunction : function () {
            return function () { //闭包不属于obj，里面的this指向window
                return this.user;
            };
        }
    };
    
    alert(obj.getUserFunction()()); //The window

使用对象冒充：可以强制指向某个对象

       var user = 'The Window';
    　　var obj = {
        　　user : 'The Object',
        　　getUserFunction : function () {
            　　return function () { //闭包不属于obj，里面的this指向window
                　　return this.user;
            　　};
        　　}
    　　};
    
    alert(obj.getUserFunction()()); //The window
    alert(obj.getUserFunction().call(obj)); //The Object    

也可以从上一个作用域中得到对象

       var user = 'The Window';
    var obj = {
        user : 'The Object',
        getUserFunction : function () {
            //这里作用域的this是obj
            var that = this;//将这里的作用域交给that
            return function () { 
                //这里作用域的this是window
                return that.user;
            };
        }
    };
    
    alert(obj.getUserFunction()()); //The Object

闭包测试题

闭包测试题1

<body>
<script type="text/javascript">
  var name = "The Window";
  var object = {
    name: "My Object",
    getNameFunc: function () {
      return function () {
        return this.name;
      };
    }
  };
  console.log(object.getNameFunc());  // 结果是匿名函数体ƒ () {return this.name;}

  // 结果是The Window，因为this指向window
  // 总体流程是这样的getNameFunc方法是通过object对象调用的，这时候getNameFunc里的this指向的是object对象
  // 但是调用getNameFunc方法返回的是一个方法，然后直接()进行直接调用，这时候方法里面的this指向的是window
  console.log(object.getNameFunc()());  
</script>
</body>

<body>
<script type="text/javascript">
  var name2 = "The Window";
  var object2 = {
    name2: "My Object",
    getNameFunc: function () {
      var that = this;
      return function () {
        return that.name2;
      };
    }
  };
  console.log(object2.getNameFunc());  // 结果是匿名函数体ƒ () {return that.name2;}

  // 结果是My Object，因为that指向object2对象
  // 总体流程是这样的getNameFunc方法是通过object2对象调用的，这时候getNameFunc里的this指向的是object对象
  // 使用that变量记录了this的指向，这时候方法里面的that指向的是object2（使用了闭包）
  console.log(object2.getNameFunc()());
</script>
</body>

闭包测试题2

<body>
  <script>
    function fun(n, o) {
      console.log(o)
      return {
        fun: function (m) {
          return fun(m, n)// 这里n使用了外部函数中的n也就是0，再次调用fun函数（外部的fun函数）参数中的o也就是n
        }
      }
    }
    var a = fun(0) // undefined
    a.fun(1) // 0 ,每次调用的时候产生了新的闭包，但是没有被接收，所以就失效了，所以n一直都是第一次传进来的0
    a.fun(2) // 0
    a.fun(3) // 0


    var b = fun(0).fun(1).fun(2).fun(3) //undefined,0,1,2

    var c = fun(0).fun(1) // undefined, 0
    c.fun(2) // 1
    c.fun(3) // 1
  </script>
</body>