JavaScript匿名函数和闭包

时间 2020-03-09

原文原文链接

概述

在JavaScript前端开发中，函数与对其状态即词法环境（lexical environment）的引用共同构成闭包（closure）。也就是说，闭包可让你从内部函数访问外部函数做用域。在JavaScript，函数在每次建立时生成闭包。匿名函数和闭包能够放在一块儿学习，能够加深理解。本文主要经过一些简单的小例子，简述匿名函数和闭包的常见用法，仅供学习分享使用，若有不足之处，还请指正。前端

普通函数

普通函数由fucntion关键字，函数名，() 和一对{} 组成，以下所示：闭包

1 function box(){
2     return 'Hex';
3 }
4 alert(box());

匿名函数

顾名思义，匿名函数就是没有实际名字的函数。单独的匿名函数没法运行，以下所示：函数

1 function (){
2     return 'Hex';
3 }
4 //以上，会报错：缺乏标识符

如何解决匿名函数不能执行的问题呢？有以下几种方法：性能

1. 把匿名函数赋值给变量，以下所示：学习

1 //把匿名函数赋值给变量
2 var box=function(){
3     return 'Hex';
4 }
5 alert(box());

2. 经过自我执行来调用函数，格式以下：(匿名函数)()优化

1 (function(){
2     alert('Hex');
3 })();

3. 把匿名函数自我执行的返回值赋值给变量，以下所示：this

1 var box=(function(){
2     return 'Hex';
3 })();
4 alert(box);//注意：此处不带括弧

4. 或者省去变量，以下所示：spa

1 alert((function() {
2     return 'Hex';
3 })());

自我执行匿名函数如何传递参数呢？以下所示：prototype

1 (function(age) {
2     alert('Hex--' + age);
3 })(30);

闭包（closure）

闭包是由函数以及建立该函数的词法环境组合而成。这个环境包含了这个闭包建立时所能访问的全部局部变量。简单理解：函数里面套函数，子函数能够访问父函数的做用域里面的变量。code

1. 函数里面放匿名函数，以下所示：

 1 function box(){
 2     //闭包
 3     return function(){
 4         return 'Hex';
 5     }
 6 }
 7 alert(box()());
 8 //或者
 9 var b=box();
10 alert(b());

2. 经过闭包返回局部变量，使用闭包能够有一个优势，和是它的缺点，能够是局部变量驻留在内存中。

1 function box(){
2     var age=100;//此变量为函数的局部变量，外部没法访问
3     return function(){
4         return age;
5     }
6 }
7 alert(box()());

闭包和全局变量相比较

1. 使用全局变量累加，以下所示：

1 var age=100;
2 function box(){
3     age++;
4 }
5 alert(age);
6 box();
7 alert(age);
8 box();
9 alert(age);

2. 使用局部变量累加，以下所示：

1 function box(){
2     var age=100;
3     age++;
4     return age;
5 }
6 alert(box());//没法实现累加
7 alert(box());//没法实现累加
8 alert(box());//没法实现累加

3. 使用闭包实现累加，以下所示：

 1 function box(){
 2     var age=100;
 3     return function(){
 4         age++;
 5         return age;
 6     }
 7 }
 8 var b=box();//将返回值赋值给b
 9 alert(b());//实现累加
10 alert(b());//实现累加
11 alert(b());//实现累加
12 b=null;//使用闭包在调用结束时不会当即销毁内存，致使性能降低,因此须要解除占用

差别：使用全局变量，容易引发命名冲突，且系统性能降低。

循环匿名函数取值问题

1. 循环里的匿名函数取值问题，以下所示：没有实现arr[0]=0,arr[1]=1 ...arr[4]=4的效果

 1 function box(){
 2     var arr=[];
 3     for (var i=0;i<5;i++) {
 4         arr[i]=function(){
 5             return i;
 6         }
 7     }
 8     //函数返回以前，循环已经结束，i=5
 9     return arr;
10 }
11 var b=box();
12 for (var i=0;i<5;i++) {
13     alert(b[i]()); //此时返回的都是5，没有实现arr[0]=0,arr[1]=1 ...arr[4]=4的效果
14 }

以上问题如何优化呢？

方法1，直接赋值，不采用闭包，以下所示：

 1 function box(){
 2     var arr=[];
 3     for (var i=0;i<5;i++) {
 4         arr[i]=i; //直接赋值
 5     }
 6     //函数返回以前，循环已经结束，i=5
 7     return arr;
 8 }
 9 var b=box();
10 for (var i=0;i<5;i++) {
11     alert(b[i]); 
12 }

方法2，经过匿名函数的自我执行，以下所示：

 1 function box(){
 2     var arr=[];
 3     for (var i=0;i<5;i++) {
 4         arr[i]=(function(num){
 5         　　//此处能够有其余一些逻辑
 6         　　return  num;
 7         })(i);
 8     }
 9     return arr;
10 }
11 var b=box();
12 for (var i=0;i<5;i++) {
13     alert(b[i]); 
14 }

方法3，将变量驻留在内存中，以下所示：

 1 function box(){
 2     var arr=[];
 3     for (var i=0;i<5;i++) {
 4         arr[i]=(function(num){
 5             //此处能够有其余一些逻辑
 6             return function(){
 7             　　return num;
 8             };
 9         })(i);
10     }
11     return arr;
12 }
13 var b=box();
14 for (var i=0;i<5;i++) {
15     alert(b[i]()); 
16 }

关于this的指向问题

对于对象内部，this指向对象自己，以下所示：

1 var box={
2     getThis:function(){
3         return this;
4     }
5 };
6 alert(box.getThis());//输出[object Object] //此处this指box对象

1 var user='The window';
2 var box={
3     user:'The box',
4     getUser:function(){
5         return this.user;
6     }
7 }
8 alert(box.getUser());//输出：the box

this在闭包中，指示window对象，因此闭包在运行时指向window，以下所示：

1 var box1 ={
2     getThis:function(){
3         return function(){
4             return this;
5         }
6     }
7 };
8 alert(box1.getThis()()); //输出[object Window]//此处this是window对象

 1 var box1={
 2     user:'The box',
 3     getUser:function(){
 4         //此处的做用域是box1
 5         return function(){
 6             //此处的做用域是widow
 7             return this.user;
 8         };
 9     }
10 }
11 alert(box1.getUser()());//输出：the window ，表示闭包在运行时模拟this指向window

如何让闭包的this指向box呢？能够有以下两种方法，以下所示：

 1 alert(box1.getUser().call(box1));//对象冒充
 2 //能够将box的做用域对象传递给闭包
 3 var box1={
 4     user:'The box',
 5     getUser:function(){
 6         var that=this;
 7         return function(){
 8             return that.user;
 9         };
10     }
11 }
12 alert(box1.getUser()());

缺点：闭包没法释放对象，容易致使内存泄漏，以下所示：

 1 function box(){
 2     var a1=document.getElementById('A01');
 3     var txt=a1.innerHTML;
 4     a1.onclick=function(){
 5         //若是a1为null，则会报错
 6         //alert(a1.innerHTML);//点击事件获取内容,
 7         alert(txt);
 8     }
 9     //如无下面一句，则会致使内存没法释放对象a1
10     a1=null;//此处须要手动将a1释放，等待回收
11 }
12 box();

块级做用域

模仿块级做用域，面向对象的思想，封装变量。普通函数没有块级做用域的概念，以下所示：

1 function box(){
2     for (var i=0;i<5;i++) {
3     
4     }
5     alert(i);//输出：5，表示出了for语句块，i依然能够访问
6 }
7 box();

如何让i私有化，出了做用域，不能够访问呢?能够采用匿名函数的自我执行，则出了做用域就会访问不到，以下所示：

1 function box(){
2     (function(){
3         for (var i=0;i<5;i++) {
4                     
5         }
6     })();
7     //alert(i);//报错：提示“i”未定义
8 }
9 box();

全局变量的私有做用域，减小变量的命名冲突，以下所示：

1 (function(){
2     //此处就是全局做用域里面的私有做用域
3     var age=100;
4     alert(age);
5 })();
6 //alert(age);////报错：提示“age”未定义

普通函数和构造函数的区别：首字母大写。以下所示：对象的属性和函数都是public类型的

 1 function Box(){
 2     this.age=100; //此处是公有属性，没法私有化
 3     //函数也是公有函数
 4     this.run=function(){
 5         return 'running....';
 6     }
 7 }
 8 var box=new Box();
 9 alert(box.age); //经过对象能够访问
10 alert(box.run());//经过对象能够访问

如何将公有属性，私有化呢? 以下所示：

 1 function Box(){
 2     var age=100;//私有变量，外部访问不到        
 3     function run(){//私有函数，外部访问不到
 4         return 'running....';
 5     }
 6     //对外公布的访问接口，能够访问私有内容
 7     this.go=function(){
 8         return age+' '+run();
 9     }
10 }
11 var box=new Box();
12 alert(box.go());

经过构造函数传递参数，以下所示：

 1 function Box(v){
 2     var user=v;
 3     this.getUser=function(){
 4         return user;
 5     };
 6     this.setUser=function(v){
 7         user=v;
 8     }
 9 }
10 var box=new Box('Hex');
11 alert(box.getUser());
12 //对象方法能够在建立的时候，建立屡次

注意：经过构造函数建立对象，在每次建立的时候，都会分配不一样的地址。

静态私有变量

采用静态私有变量，能够实现数据的共享，以下所示：

 1 (function(){
 2     var user=''; //私有变量
 3     Box=function(value){//必须全局构造函数，将匿名函数赋值给Box,不然外部没法访问
 4         user=value;
 5     }
 6     Box.prototype.getUser=function(){
 7         return user;
 8     };
 9     Box.prototype.setUser=function(value){
10         user=value;
11     };
12 })();
13 var box=new Box('AAAA'); //第一次实例化
14 alert(box.getUser());//输出AAAA
15 var box2=new Box('BBBB');//第二次实例化
16 alert(box.getUser());//输出BBBB

单例对象

单例即只有一个实例化的对象，能够有两种实现方式。

1. 经过字面量的方式实现，以下所示：

1 var box={
2     user:'hex',
3     go:function(){
4         return user+' is running....';
5     }
6 };
7 alert(box.go());

2. 经过匿名函数的自我执行返回对象的方式实现，以下所示：

 1 var box=function(){
 2     var user='Hex'; //私有变量
 3     function run(){ //私有函数
 4         return ' is running....';
 5     }
 6     //返回一个对象
 7     var obj= {
 8         //公共特权方法
 9         going:function(){
10             return user+run();
11         }
12     }
13     return obj;
14 }();
15 alert(box.going());

备注

望岳

做者：杜甫 (唐)

岱宗夫如何？齐鲁青未了。造化钟神秀，阴阳割昏晓。荡胸生曾云，决眦入归鸟。会当凌绝顶，一览众山小。