函数表达式---私有变量

私有变量

JavaScript没有私有属性的概念；所有的对象属性都是公有的。不过，却有一个私有变量的概念。任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数的外部访问这些变量。

    function box() {
        var age = 100;                          //私有变量，外部无法访问
    }

1.利用闭包创建访问私有变量的方法

而通过函数内部创建一个闭包，那么闭包通过自己的作用域链也可以访问这些变量。而利用这一点，可以创建用于访问私有变量的公有方法。

    function Box() {
        var age = 100;                          //私有变量
        function run() {                        //私有函数
            return '运行中...';
        }
        this.get = function () {                    //对外公共的特权方法
            return age + run();
        };
    }
    var box = new Box();
    console.log(box.get());

2.通过构造方法传参来访问私有变量。

    function Person(value) {
        var user = value;                       //这句其实可以省略
        this.getUser = function () {
            return user;
        };
        this.setUser = function (value) {
            user = value;
        };
    }

但是对象的方法，在多次调用的时候，会多次创建。可以使用静态私有变量来避免这个问题。

3.静态私有变量

通过块级作用域(私有作用域)中定义私有变量或函数，同样可以创建对外公共的特权方法。

    (function () {
        var age = 100;
        function run() {
            return '运行中...';
        }
        Box = function () {};                   //构造方法
        Box.prototype.go = function () {            //原型方法
            return age + run();
        };
    })();
    var box = new Box();
    console.log(box.go());

上面的对象声明，采用的是Box = function () {} 而不是function Box() {} 因为如果用后面这种，就变成私有函数了，无法在全局访问到了，所以使用了前面这种。

(function () {
        var user = '';
        Person = function (value) {             
            user = value;
        };
        Person.prototype.getUser = function () {
            return user;
        };
        Person.prototype.setUser = function (value) {
            user = value;
        }
    })();

使用了prototype导致方法共享了，而user也就变成静态属性了。(所谓静态属性，即共享于不同对象中的属性)。

4.模块模式

之前采用的都是构造函数的方式来创建私有变量和特权方法。那么对象字面量方式就采用模块模式来创建。

    var box = {                                 //字面量对象，也是单例对象
        age : 100,                              //这是公有属性，将要改成私有
        run : function () {                     //这时公有函数，将要改成私有
            return '运行中...';
        };
    };

私有化变量和函数：
    var box = function () {
        var age = 100;
        function run() {
            return '运行中...';
        }
        return {                                //直接返回对象
            go : function () {
                return age + run();
            }
        };
    }();

上面的直接返回对象的例子，也可以这么写：
    var box = function () {
        var age = 100;
        function run() {
            return '运行中...';
        }
        var obj =  {                            //创建字面量对象           
            go : function () {
                return age + run();
            }
        };
        return obj;                         //返回这个对象
    }();

字面量的对象声明，其实在设计模式中可以看作是一种单例模式，所谓单例模式，就是永远保持对象的一个实例。
增强的模块模式，这种模式适合返回自定义对象，也就是构造函数。

    function Desk() {};
    var box = function () {
        var age = 100;
        function run() {
            return '运行中...';
        }
        var desk = new Desk();                  //可以实例化特定的对象
        desk.go = function () {
            return age + run();
        };
        return desk;
    }();
    console.log(box.go());