Javascript之匿名函数(私有变量)(转)

 

严格来讲，JavaScript中没有私有成员的概念；所哟对象属性都是公开的。不过，有一个私有变量的概念。任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数的外部访问这些变量。私有变量包括函数的参数、局部变量和函数内定义的其他函数。如：

 

1 2 3 4

function add(num1,num2){     var sum=num1+num2;     return sum;  }

在这个函数内部，有3个私有变量：num1、num2和sum。如果在这个函数内部创建一个闭包，那么闭包通过自己的作用域链也可以访问这些变量，利用这一点，就可以创建用于访问私有变量的公用方法。

我们把有权访问私有变量和私有函数的公有方法叫做特权方法。

1.构造函数定义法

有两种在对象上创建特权方法的方式。第一种是在构造函数中定义特权方法，基本模式如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

function myobject (){          //私有属性和私有函数       var privateVariable=10;             function privatevateFunction(){          return false ;      }             //特权方法       this .publicMethod= function (){          privateVariable++;          return privatevateFunction();      }; }

这个模式在函数内部定义了所有私有变量和函数。然后，又继续创建了能够访问这些私有成员的特权方法。能够在构造函数中定义特权方法，是因为特权方法作为闭包有权访问在构造函数中的所有变量和函数。

利用私有和特权方法，可以隐藏那些不该被直接修改的数据，例如：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

function Persom(name){             this .getName= function (){         return name;      };         this .setName= function (value){         name=value;      }; }    var person= new Person( "zxj" ); alert(person.getName());    //zxj person.setName( "Greg" ); alert(person.getName());    //Greg

在以上构造函数中定义了两个特权方法：getName()和setName()。这两个方法都可以在函数外部使用，而且都有权访问私有变量name。

构造函数定义法，也是构造函数，构造函数有的缺点，它同样也存在。

2.静态私有变量

通过在私有作用域中定义私有变量或函数，同样也可以创建特权方法，基本模式如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

( function (){              //私有变量和私有函数        var privateVariable=10;        function privareFunction(){           return false ;        };                  //构造函数         MyObject= function (){        };           //公有/特权方法         MyObject.prototype.publicMethod= function (){            privateVariable++;            privareFunction();        };    } )()

这 个模式创建了一个私有作用域，并在其中封装了一个构造函数级相应的方法。在私有作用域中，首先定义了私有变量和私有函数，然后定义了一个构造函数及其公有 方法。公有方法是在原型上定义的，这一点体现了典型的原型模式。需要注意的是，这个模式在定义构造函数是并没有使用函数声明，而是使用的函数表达式。函数 声明只能创建局部函数，出于相同原因，在声明MyObject时也没使用var.记住：初始化未经声明的变量，总会创建一个全局变量。因此，MyObject就成了全局变量，能够在私有作用域之外被访问。

与构造函数定义特权的区别在于：私有变量和函数是由实例共享的。由于特权方法是在原型上定义的，因此所有实例都使用同一个函数。而这个特权方法，作为闭包，总是保存着对包含作用域的引用。 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

( function (){                         var name = "" ;                     Person = function (value){                              name = value;                          };                     Person.prototype.getName = function (){              return name;          };                     Person.prototype.setName = function (value){              name = value;          }; })();                var person1 = new Person( "zxj" ); alert(person1.getName());   //"zxj" person1.setName( "Greg" ); alert(person1.getName());   //"Greg"                       var person2 = new Person( "Michael" ); alert(person1.getName());   //"Michael" alert(person2.getName());   //"Michael"

一这种方式创建静态私有变量会因为使用原型而增进代码的复用，但每个实例都没有自己的私有变量。到底使用实例变量还是静态私有变量，最终还是有具体业务决定。

3.模块模式

前面模式用于自定义类型创建私有变量和特权方法。

模块模式是为单例创建私有变量和特权方法，单例就是指，只有一个实例的对象。

JavaScript是以对象字面量的方式创建单例对象的。

1 2 3 4 5 6

var singlton={      name:value,      method: function {         //这是方法的代码     } }

模块模式通过单例添加私有变量和特权放哪广发能够使其得到增强，基本形式如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

var singlton= function {                //私有变量和私有函数         var privateVaiable= 10 ;        function privateMethod(){            return false ;        };        //公有/特权方法        return {          publicProperty: true ,          piblicMethod: function (){             privateVaiable++;             return privateMethod();            }        }   }();

这 个模块使用了一个返回对象的匿名函数。在这个匿名函数内部，首先定义了私有变量和函数。然后，将一个对象字面量作为函数的值返回。返回的对象字面量中只包 含可以公开的属性和方法。由于这个对象是在匿名函数内部定义的，因此它的公有方法有权访问私有变量和函数。从本质上讲，这个对象字面量定义的是单例的公共 接口。这种模式在需要对单例进行某些初始化，同时有需要维持其私有变量时是非常有用的，如

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

function BaseComponent(){ }    function OtherComponent(){ }    var application = function (){         //私有变量和函数      var components = new Array();         //初始化      components.push( new BaseComponent());         //公有      return {          getComponentCount : function (){              return components.length;          },             registerComponent : function (component){              if ( typeof component == "object" ){                  components.push(component);              }          }      }; }();    application.registerComponent( new OtherComponent()); alert(application.getComponentCount());  //2

这 个简单的例子创建了一个用于管理组件的application对象。在创建这个对象的过程中，首先声明了一个私有的components数组，并向数组中 添加一个BaseComponent的新实例(这里不需要关心BaseComponent的代码，我们只是用他来展示初始化操作)。而返回对象的 getComponentCount()和registerComponent ()方法，都有权访问数组components的特权方法。前者只是发那 个会已注册的组件数目，后则用于注册新组件。

一这种模式创建的每一个单例都是Object的实例，因为最终要通过一个对象字面量来表示它。单例通常都是作为全局对象存在的。

4.增强的模块模式

增强的模块模式适合那些单例必须是某种类型的实例，同时还必须添加某些属性或(和)方法对齐加以增强的情况。如下所示：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

var singlton= function {                //私有变量和私有函数         var privateVaiable=10;        function privateMethod(){            return false ;        };        //创建对象      var object= new CustomType();             //公有/特权方法        object.publicProperty= true ;         object.piblicMethod= function (){           privateVaiable++;             return privateMethod();        };      //返回这个对象      return object; }();

如果前面演示模块模式的例子中的application对象必须是BaseComponent的实例，我们可以使用一下代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

function BaseComponent(){ }    function OtherComponent(){ }    var application = function (){         //私有变量和私有函数         var components = new Array();         //创建对象       components.push( new BaseComponent());         //创建application的一个局部副本      var app = new BaseComponent();         //公共      app.getComponentCount = function (){          return components.length;      };         app.registerComponent = function (component){          if ( typeof component == "object" ){              components.push(component);          }      };         //返回这个副本      return app; }();    alert(application instanceof BaseComponent); application.registerComponent( new OtherComponent()); alert(application.getComponentCou