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()); //

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) //

    a.fun(3) //

    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) //

    c.fun(3) //

  </script>

</body>

巴特西

JavaScript的函数闭包详细解释

最新文章

热门文章