JavaScript的所有成员（属性+方法）都是公有的，但是我们有方法模拟出类似于OOP一样的私有方法。

以下使用例子Person，假如我们需要一个toStr的私有方法，只能在Person内部才能访问。 其中printInfo方法为公有，将使用到toStr方法和其他私有方法。

1.在构造函数中定义私有方法

//构造函数
function Person(name,age){
    this.name = name;
    this.age = age;

    //直接在constructor中定义私有方法
    function privateMethod(){
        console.log("in private method");
    }
    //使用var在构造函数定义私有方法
    var toStr = function(){
        return this.name + ' is ' + this.age;
    }

    //公有方法
    this.printInfo = function(){
        console.log(toStr());
        privateMethod();
    }
}
//test case
var p = new Person('Jaskey',24);
p.printInfo();//两个私有方法能访问，但是toStr字段访问有问题.本机测试显示：  is undefined
p.toStr();//p.toStr is not a function

以上方法，我们的确构造了两个私有的方法toStr和privateMethod且在外部不能访问而内部可以访问。

但从打印的结果显示toStr并不能正确的访问到Person对象中的name和age。原因是当printInfo方法调用toStr时，toStr被当成了函数调用，所以this的scope被绑定到了全局（浏览器中即window）。

要解决这个问题，我们必须要让toStr调用时，this绑定到Person的对象中，所以调用toStr时，可使用call或者apply方法调用。如：toStr.call(this)。

修改版本：

function Person(name,age){
    this.name = name;
    this.age = age;

    //直接在constructor中定义私有函数
    function privateMethod(){
        console.log("in private method");
    }
    //使用var定义私有函数
    var toStr = function(){
        return this.name + ' is ' + this.age;
    }

    this.printInfo = function(){
        console.log(toStr.call(this));//把this绑定到当前的对象
        privateMethod.call(this);//为了统一，把privateMethod的this都绑定到正确的scope
    }
}

问题：

使用这种在构造函数中定义私有方法的方式，有两个问题：

1.构造函数中的私有方法并不属于prototype，所以prototype的方法不可以访问这样的方法：

Person.prototype.myPublicMethod=function(){
    toStr();//toStr is not defined
}

2.内存消耗。每一次new一个Person对象时,每个函数都会重新创建一份,而我们更希望是share同一个函数对象。

2.使用Module Pattern实现

Douglas Crockford 有一个模式叫“Module Pattern”, 可以使用闭包的方法解决实现私有方法的问题，并且可读性非常高。

使用这个方法，我们自己构造一个Person的原型对象，利用一个闭包，则让其能访问外部的私有方法。

同理，由于需要绑定正确的this作用域，我们使用call方法调用

//构建一个原型对象
Person.prototype = (function(){
    /******私有方法定义*****/

    //通过var定义
    var toStr = function(){
        return this.name + " is " + this.age
    }

    //直接定义
    function privateMethod(){
        console.log("in private method");
    }


    return {//返回的这个函数会返回一个原型对象
        constructor:Person,//把原型的constructor属性设置到正确的构造函数

        /*******公有方法*******/
        printInfo:function(){
            console.log("printing info:",toStr.call(this));
        },

        publicMethod:function(){
            privateMethod.call(this);
        }
    }

})();//注意这里的括号表示立刻执行此匿名函数，返回原型对象


//test case
var p = new Person('Jaskey',24);
p.printInfo();//printing info: Jaskey is 24
p.publicMethod();// in private method
p.toStr();//"undefined is not a function"

通过返回一个新的原型对象，该原型对象可以访问到私有的方法，而且可读性非常高,私有的方法放到原型外面，原型里面的方法都是公有方法。

定义一个调用方法以正确this调用所有私有方法

像这样每次的私有方法调用，都需要重新绑定this的scope，非常繁琐。能不能把这个操作封装起来呢？ 答案是有的，我们可以定义一个_方法，该方法接受一个函数指针，然后返回另外一个this绑定到当前对象的函数，以便正确调用:

    //返回一个函数，该函数的this绑定到当前对象
    _:function(fun){
        var that = this;//保存当前对象作用域
        return function(){//返回一个函数，该函数会调用目标函数，但this绑定到that作用域
            return fun.apply(that,arguments);//记得return
        }
    }

以第二个闭包的方法为例，最后的Person版本如下:

function Person(name,age){
    this.name = name;
    this.age = age;    
}


Person.prototype = (function(){
/******私有方法定义*****/
    var toStr = function(){
        return this.name + " is " + this.age;
    }

function privateMethod(param){
    console.log("in privateMethod param = ",param);
    this.publicMethod2();
}

return {//返回一个原型对象
    constructor:Person,//把原型的constructor属性设置到正确的构造函数

    /*******公有方法*******/
    printInfo:function(){
        console.log("-------printing info-------");
        console.log("printing info:",this._(toStr));
        this._(privateMethod)('param from printInfo')
        console.log("-------end of printing info-------");
    },

    publicMethod:function(){
        console.log("-------public Method-------");
        this._(privateMethod)('param from pubicMethod');
        console.log("-------end of Public Method-------");
    },
    publicMethod2:function(){
        console.log('in publicMethod2');
    },

    //返回一个函数，该函数的this绑定到当前对象
    _:function(fun){
        var that = this;
        return function(){
            return fun.apply(that,arguments);//注意return
        }
    }
}

})();//立刻执行

//test case:
var p = new Person('Jaskey',24);
p.printInfo();
p.publicMethod();
//p._(toStr)();//toStr is not defined