javascript-匿名函数、闭包应用(3).

模仿块级作用域

 1 function box()
 2         {
 3             //包含在我执行的匿名函数，就可以实现私有作用域
 4             (function()
 5             {
 6                 for(var i=0 i<5; i++)
 7                 {
 8                     alert(i);
 9                 }
10                             //这里面使用的变量
11             })();            //出了这里被销毁了
12
13             alert(i);
14         }
15
16         box();

这里就是全局的私有作用域

1 (function()
2         {
3             var age =100;
4             alert(age);
5         })();
6         alert(age);

私有变量

 1 //首先私有变量是没有办法访问的
 2         function box()
 3         {
 4             var age = 100;   //私有变量,外部无法访问
 5         }
 6         alert(age);
 7
 8         //但是属性和方法是公有的
 9         function Box()
10         {
11             this.age=100;                    //属性,公有的
12             this.run=function()                //方法,公有的
13             {
14                 return ‘运行中...‘;
15             }
16         }
17
18         var box1=new Box();
19         alert(box1.age);
20         alert(box1.run());

★★私有变量私有函数 怎么通过一个公共的方法访问[其实就是利用 作用的关系（词法作用域）嵌套方法内可以访问到 变量 ，方法又是共有的特性来实现]

 1 function Box()
 2         {
 3             //私有变量
 4             var age=100;
 5             var num=‘Jack‘;
 6
 7             //私有函数
 8             function run()
 9             {
10                 return num+‘运行中...‘;
11             }
12
13             this.publicGo = function()       //对外可见的公共接口,特权方法
14             {
15                 return age+run();
16             }
17             this.getAge=function()
18             {
19                 return age;
20             }
21         }
22
23         var box= new Box();
24         alert(box.publicGo());                //100Jack运行中...

★★通过 构造函数传递参数

 1 function Box(value)
 2         {
 3             var user=value;
 4             this.getUser =function()
 5             {
 6                 return user;
 7             }
 8             this.setUser=function(value1)
 9             {
10                 user=value1;
11             }
12         }
13
14         var box =new Box(‘Lee‘);
15         alert(box.getUser());
16         box.setUser(‘OOO‘);            //可以设置
17         alert(box.getUser());

----但问题是 匿名函数会被多次创建 不是共享解决如下

★★块级作用域访问 静态私有变量 私有函数

 1 (function()
 2         {
 3             var user =‘‘;           //私有变量
 4             Box=function(value)        //Box 没有var 所以是全局,构造函数
 5             {
 6                 user =value;
 7             };
 8             Box.prototype.getUser=function()
 9             {
10                 return user;
11             }
12             Box.prototype.setUser=function(value)
13             {
14                 user =value;
15             }
16
17         })();
18
19         var box= new Box(‘LEE‘);
20         alert(box.getUser());            // LEE
21
22         var box2=new Box(‘KKK‘);
23         alert(box.getUser());            // KKK
24
25         box2.getUser(‘OOOO‘);
26         alert(box.getUser());            // OOOO
27
28         //ps：使用了prototype导致方法共享了,而user也就变成静态属性了。(所谓静态属性，即共享于不同对象中的属性)

★★★★模块模式-简单提下

1 //什么叫 单例,就是永远只实例化一次,其实就是字面量对象声明方式
2
3         var box = {          //第一次实例化,无法第二次实例化,那么就是单例
4             user=‘lee‘,
5             run:function()
6             {
7                 return ‘远行中...‘;
8             }
9         }

 1 //私有化变量和函数
 2 var box=function()
 3         {
 4             var user =‘lee‘;               //私有变量
 5             function run()                //私有函数
 6             {
 7                 return ‘运行中‘;
 8             }
 9
10             return{                       //这里就是对外特权方法
11                 publicGo:function()
12                 {
13                     return user +run();
14                 }
15             };
16             /*
17             var obj={                       //这里就是对外特权方法
18                 publicGo:function()
19                 {
20                     return user +run();
21                 }
22             }
23             return obj;
24             */
25         }();
26
27         alert(box.publicGo());