js的模块化

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

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

1、利用构造函数本身：

function Text(){
              var a = null;
              var b =function(){
                  alert(a);
              };
              this.public = function(){
                  return a ;
              };
              this.publicset = function(value){
                      a = value;
              };
          }

          var c = new Text();
          c.publicset("11");
          alert(c.public());

          var d = new Text();
          d.publicset("222");
          alert(c.public());

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

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

 

2、静态私有变量：

var text = (function(){
                  var a = null;
                  var b = function(){
                      return a ;
                  };

                  var public = function(value){                    //特权方法
                  };
                  public.prototype.setName = function(value){
                      a = value;
                      return this;
                  };
                  public.prototype.getName = function(){
                      return a;
                  };
                  return public;                    //返回特权方法,返回给text
          })();

          var c = new text();
          c.setName("ac");
          alert(c.getName());            //ac

          var d = new text();
          d.setName("111");
          alert(c.getName());            //111

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

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