深入浅出JavaScript之闭包,JavaScript学习总结
分类:微服架构

闭包(closure)是掌握Javascript从人门到深入一个非常重要的门槛,它是Javascript语言的一个难点,也是它的特色,很多高级应用都要依靠闭包实现。下面写下我的学习笔记~

闭包(closure)是掌握Javascript从人门到深入一个非常重要的门槛,它是Javascript语言的一个难点,也是它的特色,很多高级应用都要依靠闭包实现。下面写下我的学习笔记~

闭包(closure)是Javascript语言的一个难点,也是它的特色,很多高级应用都要依靠闭包实现。很早就接触过闭包这个概念了,但是一直糊里糊涂的,没有能够弄明白JavaScript的闭包到底是什么,有什么用,今天在网上看到了一篇讲JavaScript闭包的文章(原文链接),讲得非常好,这下算是彻底明白了JavaScript的闭包到底是个神马东东以及闭包的用途了,在此写出来和大家分享一下,希望不理解JavaScript闭包的朋友们看了之后能够理解闭包!以下内容大部分是来自原文,我在原文的基础上加上一些代码注释和运行效果图以及少许的修改,方便大家理解!

系列目录

  • 深入浅出JavaScript之闭包(Closure)
  • 深入浅出JavaScript之this
  • 深入浅出JavaScript之原型链和继承

闭包-无处不在 

在前端编程中,使用闭包是非常常见的,我们经常有意无意,直接或间接用到了闭包。闭包可以使传递数据更加灵活(比如处理一些点击事件)

1
2
3
4
5
6
7
!function() {     
  var localData = "localData here";   
     document.addEventListener('click',    //处理点击事件时用到了外部局部变量,比如这里的localData      
        function(){             
           console.log(localData);
    });
}();

又比如下面这个例子:(是不是很亲切~~)

1
2
3
4
5
6
7
8
9
10
11
!function() {     
  var localData = "localData here";     
  var url = "http://www.baidu.com/";     
  $.ajax({
     url : url,         
     success : function() {             
        // do sth...             
        console.log(localData);
        }
    });
}(); 

再来看一个例子~~这种情况就是我们通常所说的闭包

1
2
3
4
5
6
7
8
function outer() {  
  var localVal = 30;   
  return function(){     
    return localVal;   
  }
}
var func = outer(); 
func(); // 30

这个例子中调用outer()返回匿名函数function(),这个匿名函数中可以访问outer()的局部变量localVal,在outer()调用结束后,再次调用func()的时候,仍然能访问到outer()的局部变量localVal

 

闭包-无处不在

在前端编程中,使用闭包是非常常见的,我们经常有意无意,直接或间接用到了闭包。闭包可以使传递数据更加灵活(比如处理一些点击事件)

!function() {      
  var localData = "localData here";    
     document.addEventListener('click',    //处理点击事件时用到了外部局部变量,比如这里的localData       
        function(){              
           console.log(localData); 
    }); 
}();

又比如下面这个例子:(是不是很亲切~~)

!function() {      
  var localData = "localData here";      
  var url = "http://www.baidu.com/";      
  $.ajax({ 
     url : url,          
     success : function() {              
        // do sth...              
        console.log(localData); 
        } 
    }); 
}();

再来看一个例子~~这种情况就是我们通常所说的闭包

function outer() {   
  var localVal = 30;    
  return function(){      
    return localVal;    
  } 
} 
var func = outer();  
func(); // 30

这个例子中调用outer()返回匿名函数function(),这个匿名函数中可以访问outer()的局部变量localVal,在outer()调用结束后,再次调用func()的时候,仍然能访问到outer()的局部变量localVal

闭包的概念

闭包,不同于一般的函数,它允许一个函数在立即词法作用域外调用时,仍可访问非本地变量。 --维基百科 

闭包就是能够读取其他函数内部变量的函数。 --阮一峰

由于在Javascript语言中,只有函数内部的子函数才能读取局部变量,因此可以把闭包简单理解成"定义在一个函数内部的函数"。

所以,在本质上,闭包就是将函数内部和函数外部连接起来的一座桥梁

一、变量的作用域

闭包的概念

闭包,不同于一般的函数,它允许一个函数在立即词法作用域外调用时,仍可访问非本地变量。 –维基百科

闭包就是能够读取其他函数内部变量的函数。 –阮一峰

由于在Javascript语言中,只有函数内部的子函数才能读取局部变量,因此可以把闭包简单理解成”定义在一个函数内部的函数”。

所以,在本质上,闭包就是将函数内部和函数外部连接起来的一座桥梁

闭包的用途

这部分转自这篇博文

闭包可以用在许多地方。它的最大用处有两个,一个是前面提到的可以读取函数内部的变量,另一个就是让这些变量的值始终保持在内存中。

1
2
3
4
5
6
7
8
9
10
11
12
function f1(){
    var n=999;
    nAdd=function(){n+=1}
    function f2(){
      alert(n);
    }
    return f2;
  }
  var result=f1();
  result(); // 999
  nAdd();
  result(); // 1000

在这段代码中,result实际上就是闭包f2函数。它一共运行了两次,第一次的值是999,第二次的值是1000。这证明了,函数f1中的局部变量n一直保存在内存中,并没有在f1调用后被自动清除。

为什么会这样呢?原因就在于f1是f2的父函数,而f2被赋给了一个全局变量,这导致f2始终在内存中,而f2的存在依赖于f1,因此f1也始终在内存中,不会在调用结束后,被垃圾回收机制(garbage collection)回收。

这段代码中另一个值得注意的地方,就是"nAdd=function(){n+=1}"这一行,首先在nAdd前面没有使用var关键字,因此nAdd是一个全局变量,而不是局部变量。其次,nAdd的值是一个匿名函数(anonymous function),而这个匿名函数本身也是一个闭包,所以nAdd相当于是一个setter,可以在函数外部对函数内部的局部变量进行操作。

 

闭包的用途

这部分转自这篇博文

闭包可以用在许多地方。它的最大用处有两个,一个是前面提到的可以读取函数内部的变量,另一个就是让这些变量的值始终保持在内存中。

function f1(){
    var n=999;
    nAdd=function(){n+=1}
    function f2(){
      alert(n);
    }
    return f2;
  }
  var result=f1();
  result(); // 999
  nAdd();
  result(); // 1000

在这段代码中,result实际上就是闭包f2函数。它一共运行了两次,第一次的值是999,第二次的值是1000。这证明了,函数f1中的局部变量n一直保存在内存中,并没有在f1调用后被自动清除。

为什么会这样呢?原因就在于f1是f2的父函数,而f2被赋给了一个全局变量,这导致f2始终在内存中,而f2的存在依赖于f1,因此f1也始终在内存中,不会在调用结束后,被垃圾回收机制(garbage collection)回收。

这段代码中另一个值得注意的地方,就是”nAdd=function(){n+=1}”这一行,首先在nAdd前面没有使用var关键字,因此nAdd是一个全局变量,而不是局部变量。其次,nAdd的值是一个匿名函数(anonymous function),而这个匿名函数本身也是一个闭包,所以nAdd相当于是一个setter,可以在函数外部对函数内部的局部变量进行操作。

闭包-封装 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
(function() {  
   var _userId = 23492;  
   var _typeId = 'item';   
   var export = {};
     
   function converter(userId) {         
     return +userId;
   }
    export.getUserId = function() {        
       return converter(_userId);    
   }
   export.getTypeId = function() {         
      return _typeId;
   }        
   window.export = export;   //通过此方式输出
}());
 
  export.getUserId(); // 23492
  export.getTypeId();  // item
  export._userId;    // undefined 
  export._typeId;    // undefined      
  export.converter; // undefined

利用闭包的特性能让我们封装一些复杂的函数逻辑,在这个例子中调用export上的方法(getUserId,getTypeId)间接访问函数里私有变量,但是直接调用export._userId是没法拿到_userId的。这也是Node里面常用到特性吧~

  要理解闭包,首先必须理解Javascript特殊的变量作用域。

闭包-封装

(function() {   
   var _userId = 23492;   
   var _typeId = 'item';    
   var export = {}; 

   function converter(userId) {          
     return +userId; 
   } 
    export.getUserId = function() {         
       return converter(_userId);     
   } 
   export.getTypeId = function() {          
      return _typeId; 
   }         
   window.export = export;   //通过此方式输出
}());

  export.getUserId(); // 23492 
  export.getTypeId();  // item 
  export._userId;    // undefined  
  export._typeId;    // undefined       
  export.converter; // undefined

利用闭包的特性能让我们封装一些复杂的函数逻辑,在这个例子中调用export上的方法(getUserId,getTypeId)间接访问函数里私有变量,但是直接调用export._userId是没法拿到_userId的。这也是Node里面常用到特性吧~

常见错误之循环闭包 

下面这个案例,我们添加3个div,值分别为aaa,bbb,ccc,我们想实现的是点击aaa输出1,点击bbb输出2,点击ccc输出3

1
2
3
4
5
6
7
document.body.innerHTML = "<div id=div1>aaa</div>" + "<div id=div2>bbb</div><div id=div3>ccc</div>"
for (var i = 1; i < 4; i++) {     
  document.getElementById('div' + i).        
    addEventListener('click', function() {        
    alert(i); // all are 4!
    }); 
}

图片 1

结果点击aaa,bbb还是ccc都是alert(4)~~

产生这样的问题在于这个i的值在初始化完成的时候就已经是4了

要达到我们想要的点击aaa输出1,点击bbb输出2,点击ccc输出3,要用到闭包的技巧,在每次循环的时候,用立即执行的匿名函数把它包装起来,这样子做的话,每次alert(i)的值就取自闭包环境中的i,这个i来自每次循环的赋值i就能输出1,2,3了

1
2
3
4
5
6
7
8
9
document.body.innerHTML = "<div id=div1>aaa</div>" + "<div id=div2>bbb</div>" + "<div id=div3>ccc</div>"
for (var i = 1; i < 4; i++) {
  !function(i){ //②再用这个参数i,到getElementById()中引用    
    document.getElementById('div' + i).      
      addEventListener('click', function() {        
      alert(i); // 1,2,3
     }); 
  }(i);  //①把遍历的1,2,3的值传到匿名函数里面

图片 2

 

常见错误之循环闭包

下面这个案例,我们添加3个div,值分别为aaa,bbb,ccc,我们想实现的是点击aaa输出1,点击bbb输出2,点击ccc输出3

document.body.innerHTML = "<div id=div1>aaa</div>" + "<div id=div2>bbb</div><div id=div3>ccc</div>";  
for (var i = 1; i < 4; i++) {      
  document.getElementById('div' + i).         
    addEventListener('click', function() {         
    alert(i); // all are 4! 
    });  
}

图片 3

结果点击aaa,bbb还是ccc都是alert(4)~~

产生这样的问题在于这个i的值在初始化完成的时候就已经是4了

要达到我们想要的点击aaa输出1,点击bbb输出2,点击ccc输出3,要用到闭包的技巧,在每次循环的时候,用立即执行的匿名函数把它包装起来,这样子做的话,每次alert(i)的值就取自闭包环境中的i,这个i来自每次循环的赋值i就能输出1,2,3了

document.body.innerHTML = "<div id=div1>aaa</div>" + "<div id=div2>bbb</div>" + "<div id=div3>ccc</div>";  
for (var i = 1; i < 4; i++) {
  !function(i){ //②再用这个参数i,到getElementById()中引用     
    document.getElementById('div' + i).       
      addEventListener('click', function() {         
      alert(i); // 1,2,3
     });  
  }(i);  //①把遍历的1,2,3的值传到匿名函数里面
}

图片 4

思考题

如果你能理解下面两段代码的运行结果,应该就算理解闭包的运行机制了。(来自阮老师)这题目总结得真妙~~

代码片段一。

1
2
3
4
5
6
7
8
9
10
var name = "The Window";
var object = {
  name : "My Object",
  getNameFunc : function(){
    return function(){
      return this.name;
    };
  }
};
alert(object.getNameFunc()());

代码片段二。

1
2
3
4
5
6
7
8
9
10
11
var name = "The Window";
var object = {
  name : "My Object",
  getNameFunc : function(){
    var that = this;
    return function(){
      return that.name;
    };
  }
};
alert(object.getNameFunc()());

  在JavaScript中,变量的作用域分两种:全局变量和局部变量。

思考题

如果你能理解下面两段代码的运行结果,应该就算理解闭包的运行机制了。(来自阮老师)这题目总结得真秒~~

代码片段一

var name = "The Window";
  var object = {
    name : "My Object",
    getNameFunc : function(){
      return function(){
        return this.name;
      };
    }
  };
  alert(object.getNameFunc()());

代码片段二

var name = "The Window";
  var object = {
    name : "My Object",
    getNameFunc : function(){
      var that = this;
      return function(){
        return that.name;
      };
    }
  };
  alert(object.getNameFunc()());

 

  在Javascript中,在函数内部可以直接读取全局变量。

 

1 var n=999;//定义全局变量n

2 function f1(){

3   alert("在函数内部访问全局变量n,n="+n);//在函数内部访问全局变量n

4 }

5 f1(); // 999

运行结果:

 

    

 

  但是反过来则不行,在函数外部无法读取函数内的局部变量。

 

1  function f1(){

2    var n=999;//在f1函数内部定义局部变量n

3  }

4  alert("在函数外部访问局部变量n,n="+n); //在函数外部访问局部变量n,错误:n未定义

运行结果:

 

  

 

  这里有一个地方需要注意,函数内部声明变量的时候,一定要使用var命令。如果不用的话,实际上是声明了一个全局变量!

 

1 function f1(){

2   n=999;

3 }

4 f1();

5 alert("n在f1函数内部没有使用var来声明,此时n就是一个全局变量,rn证明:n="+n+",window.n==n的结果是:"+(window.n==n));

运行结果:

 

  

 

二、如何从外部读取局部变量?

 

  出于种种原因,我们有时候需要得到函数内的局部变量。但是,前面已经说过了,正常情况下,这是办不到的,只有通过变通方法才能实现。

 

那就是在函数的内部,再定义一个函数。

 

复制代码

1 function f1(){

2   var n=999;//f1函数内部的局部变量n

3     //在f1函数内部定义一个f2函数

4   function f2(){

5        //在f2函数内部是可以访问局部变量n的

6     alert(n); // 999

7   }

8 }

复制代码

  在上面的代码中,函数f2就被包括在函数f1内部,这时f1内部的所有局部变量,对f2都是可见的。但是反过来就不行,f2内部的局部变量,对f1 就是不可见的。这就是Javascript语言特有的"链式作用域"结构(chain scope),子对象会一级一级地向上寻找所有父对象的变量。所以,父对象的所有变量,对子对象都是可见的,反之则不成立。既然f2可以读取f1中的局部变量,那么只要把f2作为返回值,我们不就可以在f1外部读取它的内部变量了吗!或许有人会有疑问,f2是一个函数啊,怎么能够作为f1函数的返回值返回呢,其实是可以的,JavaScript中的函数名本身就是变量,所以函数也可以当作普通变量来使用。也就是说,不仅可以像传递参数一样把一个函数传递给另一个函数,而且可以将一个函数作为另一个函数的返回值返回。

 

复制代码

 1 function f1(){

 2     var n=999;//局部变量n

 3     //在f1函数内部声明的f2函数

 4     function f2(){

 5       alert(n);

 6     }

 7 

 8     return f2;//将f2函数作为f1函数的返回值

 9   }

10   var result=f1();//f1调用完后的返回值是一个f2函数,此时result就是f2函数

11   result(); // 999,调用f2函数

复制代码

运行结果:

 

  

 

三、闭包的概念

 

  上一节代码中的f2函数,就是闭包。各种专业文献上的"闭包"(closure)定义非常抽象,比如有这样的一个闭包定义:"JavaScript闭包就是在另一个作用域中保存了一份它从上一级函数或者作用域得到的变量,而这些变量是不会随上一级函数的执行完成而销毁",对于这样的闭包定义,我是很难看懂。我的理解是,闭包就是能够读取其他函数内部变量的函数。由于在Javascript语言中,只有函数内部的子函数才能读取局部变量,因此可以把闭包简单理解成"定义在一个函数内部的函数"。所以,在本质上,闭包就是将函数内部和函数外部连接起来的一座桥梁。

 

四、闭包的用途

 

  闭包可以用在许多地方。它的最大用处有两个,一个是前面提到的可以读取函数内部的变量,另一个就是让这些变量的值始终保持在内存中。

 

怎么来理解这句话呢?请看下面的代码。

 

复制代码

 1     function f1(){

 2     var n=999;

 3         //nAdd是一个没有使用var声明的全局变量,这个变量现在指向了在f1函数内部声明的一个匿名函数

 4     nAdd=function(){n+=1}

 5     function f2(){

 6       alert(n);

 7     }

 8     return f2;

 9   }

10 

11   var result=f1();//result就是f2函数

12   result();//第一次调用result函数 999

13   nAdd();//nAdd代表的就是在f1函数内部声明的一个匿名函数,nAdd()就是在调用匿名函数

14   result();//第二次调用result函数 1000

复制代码

运行结果:

 

  

 

  在这段代码中,result实际上就是闭包f2函数。它一共运行了两次,第一次的值是999,第二次的值是1000。这证明了,函数f1中的局部变量n一直保存在内存中,并没有在f1调用后被自动清除。

 

  为什么会这样呢?原因就在于f1是f2的父函数,而f2被赋给了一个全局变量,这导致f2始终在内存中,而f2的存在依赖于f1,因此f1也始终在内存中,不会在调用结束后,被垃圾回收机制(garbage collection)回收。

 

  这段代码中另一个值得注意的地方,就是"nAdd=function(){n+=1}"这一行,首先在nAdd前面没有使用var关键字,因此 nAdd是一个全局变量,而不是局部变量。其次,nAdd的值是一个匿名函数(anonymous function),而这个匿名函数本身也是一个闭包,所以nAdd相当于是一个setter,可以在函数外部对函数内部的局部变量进行操作。

 

 五、使用闭包的注意点

 

  1)由于闭包会使得函数中的变量都被保存在内存中,内存消耗很大,所以不能滥用闭包,否则会造成网页的性能问题,在IE中可能导致内存泄露。解决方法是,在退出函数之前,将不使用的局部变量全部删除。

 

  2)闭包会在父函数外部,改变父函数内部变量的值。所以,如果你把父函数当作对象(object)使用,把闭包当作它的公用方法(Public Method),把内部变量当作它的私有属性(private value),这时一定要小心,不要随便改变父函数内部变量的值。

 

六、思考题

 

  如果能理解下面两段代码的运行结果,应该就算理解闭包的运行机制了。

 

代码片段一:

 

复制代码

 1 var name = "The Window";

 2   var object = {

 3     name : "My Object",

 4     getNameFunc : function(){

 5       return function(){

 6         return this.name;

 7       };

 8     }

 9   };

10   alert(object.getNameFunc()());

复制代码

运行结果:

 

  

 

代码片段二:

 

复制代码

 1 var name = "The Window";

 2   var object = {

 3     name : "My Object",

 4     getNameFunc : function(){

 5       var that = this;

 6       return function(){

 7         return that.name;

 8       };

 9     }

10   };

11   alert(object.getNameFunc()()); 

复制代码

运行结果:

 

  

 

下面给代码加上注释,分析上述两个代码片段的运行结果:

 

代码片段一:

 

分析如下:

 

复制代码

 1     /*

 2     在JavaScript中,我们声明的JavaScript全局对象、全局函数以及全局变量均自动成为window对象的成员。

 3     全局变量是window对象的属性。

 4     全局函数是window对象的方法。

 5     */

 6     var name = "The Window";//声明一个全局变量name,此时这个全局变量name就自动成为了window对象的一个属性

 7     //证明:

 8     alert("window.name:"+window.name);//能用window.name(对象名.属性名)的形式去访问name,那么就证明了这个全局变量name就自动成为了window对象的一个属性

 9     //声明全局对象object,此时这个全局变量object就自动成为了window对象的一个属性

10     var object = {

11          name : "My Object",//object对象的属性name

12         getNameFunc : function(){//object对象的getNameFunc函数

13                 //object对象的getNameFunc方法的返回值是一个匿名函数

14           return function(){

15                     //此时这个this指的是哪个对象呢,指的是window对象,哪个对象调用this所在的函数,this指的就是哪个对象。

16                     //证明匿名函数里面的this代表的是window对象而不是object

17                     alert("this==object的结果是:"+(this==object));

18                     alert("this==window的结果是:"+(this==window));

19             return this.name;//既然this代表的是window对象,那么this.name访问的自然就是window对象的名字"The Window"

20           };

21         }

22     };

23     //证明:全局对象object是window对象的一个属性

24     alert("window.object:"+window.object);

25     alert("window.object.name:"+window.object.name);

26     /*

27     调用完getNameFunc方法后,返回一个匿名方法,

28     此时retFn代表的就是匿名方法,现在相当于给匿名方法起了一个名字叫retFn,

29     此时的retFn函数自动成为了window对象的一个函数

30     */

31     var retFn = object.getNameFunc();

32     alert(retFn());//调用返回的匿名方法,那么是谁在调用这个匿名方法呢?是window对象

33     //证明:retFn函数是window对象的一个函数

34     alert("window.retFn():"+window.retFn());//能用window.retFn()(对象名.方法名)的形式去调用retFn方法,那么就证明了retFn函数是window对象的一个函数

复制代码

代码片段二:

 

分析如下:

 

复制代码

 1     var name = "The Window";//全局变量name

 2     //全局对象object

 3     var object = {

 4     name : "My Object",

 5 

 6     getNameFunc : function(){

 7             /*

 8             此时这个this代表的是哪个对象呢,this此时代表的是object对象,哪个对象调用this所在的函数,this指的就是哪个对象

 9             执行完that = this后,此时that也代表object对象

10             */

11             var that = this;//that是在getNameFunc函数里面声明的一个局部变量

12             //证明getNameFunc函数里面的this代表的是object对象而不是window

13             alert("this==object的结果是:"+(this==object));

14             alert("this==window的结果是:"+(this==window));

15             //证明that代表的是object对象

16             alert("that==object的结果是:"+(that==object));

17       return function(){

18             /*that是在getNameFunc函数里面声明的一个局部变量,

19             正常情况下getNameFunc函数调用完成后,that这个局部变量就会被JavaScript的GC回收,释放掉that这个局部变量所占用的内存空间,

20             但是现在that却能一直正常使用,没有被回收,

21             原因就在于getNameFunc是这个匿名函数的父函数,而getNameFunc函数调用完后会将这个匿名函数返回并被赋给了一个全局变量retFn,这导致匿名函数始终在内存中,

22             而匿名函数的存在依赖于getNameFunc函数,因此getNameFunc函数也始终在内存中,不会在调用结束后,被垃圾回收机制(garbage collection)回收。

23             既然getNameFunc函数始终在内存中,那么在getNameFunc函数内部声明的that局部变量在内存中也会一直存在,既然存在,那么当然可以继续使用了。

24             */

25         return that.name;//that代表的是object对象,那么that.name访问的自然就是object对象的名字"My Object"

26       };

27 

28     }

29 

30   };

31     var retFn = object.getNameFunc();//调用完getNameFunc方法后,返回一个匿名方法,此时retFn代表的就是匿名方法,现在相当于给匿名方法起了一个名字叫retFn

32   alert(retFn()); 

复制代码

 最后也附上一个我以前学习JavaScript闭包时写的一个例子:

 

复制代码

 1 <script type="text/javascript">

 2     function A(){

 3         var i = 0;//声明在A函数内部的局部变量i

 4         //声明在A函数的内部的子函数b

 5         function b(){

 6             alert("i = "+(++i));//在子函数b内部访问声明在A函数内部的局部变量i

 7         }

 8         return b;//返回b这个函数的地址

 9     }

10     /*

11     在执行完var c = A()后,变量c实际上是指向了函数b,b中用到了变量i,

12     再执行c()后会弹出一个窗口显示i的值(第一次为1),

13     这段代码其实就是创建了一个闭包,

14     因为函数a外的变量c引用了函数a内部的函数b

15     也就是说:当函数a的内部函数b被函数a外的一个变量引用的时候,

16     就创建了一个所谓的"闭包"

17     闭包的作用就是在a执行完并返回后,

18     闭包使得JavaScript的垃圾回收机制GC不会收回a所占用的资源,

19     因为a的内部函数b的执行需要依赖a中的变量

20     */

21     A();//此时内存中肯定会有i的空间,当执行完A()之后,GC就会回收为i分配的内存空间

22     var c = A();//这种用法,GC不会把i当成垃圾处理掉

23     c();//相当于调用b(),结果是:i=1

24     c();//结果是:i=2

25     c();//结果是:i=3

26   </script>

复制代码

运行结果:

 

  

 

  以上就是对JavaScript闭包的总结,如果有写得不对的地方,欢迎朋友们指出来,大家一起共同进步!

...

本文由10bet手机官网发布于微服架构,转载请注明出处:深入浅出JavaScript之闭包,JavaScript学习总结

上一篇:JavaScript单例模式概念与实例 下一篇:没有了
猜你喜欢
热门排行
精彩图文