第七章 函数表达式

7.4  私有变量

任意在函数中定义的变量，都可以认为是私有变量，因为不能在函数的外部访问这些变量。私有变量包括函数的参数、局部变量和在函数内部定义的其他函数

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

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

我们把有权访问私有变量和私有函数的公有方法称为特权方法。有两种在对象上创建特权方法的方式。第一种是在构造函数的中定义特权方法，基本模式如下：

function MyObject(){
    //私有变量和私有函数
    var privateVariable=10;
    function privateFunction(){
        return false;
    }

    //特权方法
    this.publicMethod=function(){
        privateVariable++;
        return privateFunction();
    }
}

对于这个例子，在创建MyObject的实例后，除了使用publicMethod()这一个途径外，没有任何办法可以直接访问privateVariable和privateFunction()。

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

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

以上代码的构造函数中定义了两个特权方法：getName()和setName()。这两个方法都可以在构造函数外部使用，而且都有权访问私有变量name。但在Person构造函数外部，没有任何办法访问name。由于这两个方法是在构造函数内部定义的，它们作为闭包能够通过作用域链访问name。私有变量name在Person的每一个实例中都不相同。

在构造函数中定义特权方法有一个缺点，那就是你必须使用构造函数模式来达到这个目的。构造函数模式的缺点是针对每个实例都会创建同样一组新方法，而使用静态私有变量来实现特权方法就能避免这个问题。

7.4.1 静态私有变量

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

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

这个模式创建了一个私有作用域，并在其中封装了一个构造函数及相应的方法。在私有作用域中，首先定义了私有变量和私有函数，然后又定义了构造函数及其公有方法。公有方法是定义在原型上的，这一点体现了典型的原型模式。这个模式在定义构造函数时并没有使用函数声明，而是使用了函数表达式。函数声明只能创建局部函数，这并不是我们想要的。同样的，我们在声明MyObject时没有使用var关键字，那么MyObject就是一个全局变量，能够在私有作用域之外被访问到。但是需要知道，在严格模式下给未经声明的变量赋值会导致错误。

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

(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("Nicholas");
alert(person1.getName());  //Nicholas
person1.setName("Grey");
alert(person1.getName());  //Grey

var person2=new Person("Michael");
alert(person1.getName());  //Michael
alert(person2.getName());  //Michael

在这个例子中变量name是一个静态的、由所有实例共享的属性。也就是说，在一个实例上调用setName()会影响所有实例。而调用setName()或新建一个Person实例都会赋予name属性一个新值。结果就是所有实例都会返回相同的值。

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

7.4.2 模块模式

前面的模式是用于为自定义类创建私有变量和特权方法的。而模块模式则是为单例创建私有变量和特权方法。所谓单例，指的就是只有一个实例的对象。按照惯例，JavaScript是以对象字面量的方式来创建单例对象的。

var singleton={
    name:value,
    method:function(){
        //这里是方法的代码
    }
}

模块模式通过单例添加私有变量和特权方法能够使其得到增强，其语法形式如下：

var singleton=function(){
    //私有变量和私有函数
    var privateVariable=10;
    function privateFunction(){
        return false;
    }
    //特权/公有方法和属性
    return {
        publicProperty:true,
        publicMethod:function(){
            privateVariable++;
            return privateFunction();
        }
    };
}();

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

var BaseComponent=function(){};
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);
            }
        }
    };
}();
console.log(application.getComponentCount()); //1
application.registerComponent(new BaseComponent());
console.log(application.getComponentCount()); //2

在Web应用程序中，经常需要使用一个单例来管理应用程序级的信息。这个简单的例子创建了一个用于管理组件的application对象。

如果我们必须创建一个对象并以某些数据对其进行初始化，同时还要公开一些能够访问这些私有数据的方法，那么就可以使用模块模式。

7.4.3  增强的模块模式

有人进一步改进了模块模式，即在返回对象之前加入对其增强的代码。这种增强的模块模式适合那些单例必须是某种类型的实例，同时还必须增加某些属性和（或）方法对其加以增强的情况。来看下面的例子。

var singleton =function(){
    //私有变量和私有函数
    var privateVariable=10;
    function privateFunction(){
        return false;
    }   
    //创建对象
    var object=new CustomType();
    //添加特权/公有属性和方法
    object.publicProperty=true;
    object.publicMethod=function(){
        privateVariable++;
        return privateFunction();
    };
    //返回这个对象
    return object;
}();

如果前面演示模块模式的例子中的application对象必须是BaseComponent的实例，那么就可以使用以下代码。

    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);  //true
    application.registerComponent(new OtherComponent());
    alert(application.getComponentCount());  //2