js的模块化

　　众所周知，js是没有块级做用域这一说法的，js只有在函数中定义的变量才是局部变量，定义在循环，条件语句中的都是全局变量，因此要实现模仿块级做用域就须要利用js的这一特性，也就是利用闭包，实现局部变量外部没法调用，只有特权方法才能实现

　　参考高级程序设计一书，提供了两种方法，分别使用于不一样的场合：

一、利用构造函数自己：

 1 function Text(){
 2               var a = null;
 3               var b =function(){
 4                   alert(a);
 5               };
 6               this.public = function(){
 7                   return a ;
 8               };
 9               this.publicset = function(value){
10                       a = value;
11               };
12           }
13 
14           var c = new Text();
15           c.publicset("11");
16           alert(c.public());
17 
18           var d = new Text();
19           d.publicset("222");
20           alert(c.public());

这里的a与b分别是局部变量与函数，外部没法直接调用，经过两个特权方法进行调用。

这里输出了两次c的name值，发现两次值相同，觉得每新建一个实例，就有对应的一组属性方法，每一次都是新建的，互不影响。

 

二、静态私有变量：

 1 var text = (function(){
 2                   var a = null;
 3                   var b = function(){
 4                       return a ;
 5                   };
 6 
 7                   var public = function(value){                    //特权方法
 8                   };
 9                   public.prototype.setName = function(value){
10                       a = value;
11                       return this;
12                   };
13                   public.prototype.getName = function(){
14                       return a;
15                   };
16                   return public;                    //返回特权方法,返回给text
17           })();
18 
19           var c = new text();
20           c.setName("ac");
21           alert(c.getName());            //ac
22 
23           var d = new text();
24           d.setName("111");
25           alert(c.getName());            //111

这里采用了另外一种方法，在内部声明了一个构造函数，并返回这个构造函数(书里采用建立一个全局构造函数，直接在外部调用这个构造函数的方法)，这个构造函数的原型定义特权函数，这样全部的实例都使用这个特权方法，不会建立新的方法。

两次输出的结果不一致，说明一个实例调用方法会影响其余实例的静态变量，这一点要注意。