【函数表达式】私有变量

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

在函数内部创建一个闭包，那么闭包通过自己的作用域链可以访问私有变量。

特权方法：有权访问私有变量和私有函数的公有方法。

在构造函数中定义特权方法

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

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

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

使用静态私有变量来定义特权方法

(function(){
    //私有变量和私有函数
    var privateVariable = 10;
    function privateFunction(){
        return false;
    }
    
    //构造函数
    MyObject = function(){};  //——>MyObject是全局函数（未使用var关键字）
    
    //公有/特权方法
    MyObject.prototype.publicMethod = function () {
        privateVariable++;
        return privateFunction();
    };
})();

与在构造函数中定义特权方法的区别：
私有变量和函数是由实例共享的。特权方法是在原型上定义的，因此所有实例都使用同一个函数。

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

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

模块模式

前面两种模式用于为自定义类型创建私有变量和特权方法。
模块模式为单例创建私有变量和特权方法。

单例：只有一个实例的对象。

//以对象字面量方式创建单例对象。
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 application = function () {
    //私有变量和私有函数
    var componets = new Array();
    
    //初始化
    componets.push(new BaseComponet());
    
    //公共
    return {
        getComponetCount: function () {
            return componets.length;
        },
        registerComponent: function (component) {
            if(typeof  component == "object"){
                componets.push(component);
            }
        }
    }
}();

增强的模块模式

在返回对象之前加入对其增强的代码。
适用于：
单例是某种类型的实例，同时还必须添加某些属性和（或）方法对其加以增强的情况。

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;
}();