深入理解JavaScript模拟私有成员

　　一般的面向对象语言C++或JAVA，对象都是有私有成员的。js中没有类的改变，同样也没有对象的私有成员这个概念。但是可以通过某些特殊写法，模拟出私有成员。

1、特权模式：

　　（1）在构造函数内部声明的变量、子函数以及参数，全部都是函数私有的，可以看作私有成员。给this指针添加的闭包，全部都是公有成员。

　　所以下面例子：参数a/b、变量_value、函数add是私有的，外面无法访问，故c1.add会报错

　　setValue和getValue是公有的，c1可以访问

function MyClass(a,b){
    //private
    var _value=;
    function add(){
        _value=a+b;
    }
    //process
    add();
    //public
    this.getValue=function(){
        return _value;
    }
    this.setValue=function(a1,b1){
        a=a1;
        b=b1;
        add();
    }
}
var c1=new MyClass(,);
var c2=new MyClass(,);
c1.setValue(,);
alert(c1.getValue());//7
alert(c2.getValue());//3
alert(c1.add());//c1中无add方法，报错c1.add is not a function(…)

　　（2）这种模拟方法的优点是代码清晰明了，缺点是每个对象的成员函数，不论是私有还是公有，都是自己独有的。即便成员函数的功能相同，但他们却是存放在不同位置的不同函数。
　　（3）这种模拟方法只模仿了一个外形。OOP语言中，每个对象的成员函数，在内存中只体现为一个单元，我们违背了这一原则。

2、私有作用域模式：

　　（1）既然模拟出了块级作用域，可以考虑把块级作用域拿来，模拟一下私有成员。

(function(){
    //private
    var _value=, _a=, _b=;
    function add(){
        _value=_a+_b;
    }
    //construct
    MyClass=function(a,b){
        _a=a;
        _b=b;
        add();
    }
    //public
    MyClass.prototype.getValue=function(){
        return _value;
    }
    MyClass.prototype.setValue=function(a1,b1){
        _a=a1;
        _b=b1;
        add();
    }
})();
var c1=new MyClass(,);
var c2=new MyClass(,);
c1.setValue(,);
alert(c1.getValue());//7
alert(c2.getValue());//7
alert(c1.add());//报错

　　（2）上面例子我们使用了块级作用域，_value、_a、_b、add都是匿名函数的私有变量；MyClass前面没有var，所有MyClass是全局变量，可以在块级作用域外部使用；getValue和setValue是通过原型模式为MyClass添加的公共方法。
　　（3）这样写，MyClass所有实例的公共方法不再单独创建，而是共享使用；而私有方法，则是共享作用域链中的add，也不是独立创建的。针对成员方法而言，已经与C++和java非常接近了。
　　（4）但这样写的缺点也是显而易见的，就是私有数据成员_value、_a、_b在各实例之间也是共享的。这些成员，相当于static成员。

3、综合模式

(function(){
    //private static
    var _count=;
    function add(a,b){
        return a+b;
    }
    //construct
    MyClass=function(a,b){
        //private
        var _data={ value: }
        //process
        _data.value=add(a,b);
        _count++;
        //public
        this.data=function(){return _data;}
    }
    //public
    MyClass.prototype.getValue=function(){
        return this.data().value;
    }
    MyClass.prototype.setValue=function(a,b){
        this.data().value=add(a,b);
    }
    MyClass.prototype.getCount=function(){
        return _count;
    }
})();  

var c1=new MyClass(,);
var c2=new MyClass(,);
c1.setValue(,);
alert(c1.getValue());//7
alert(c2.getValue());//3
alert(c1.getCount());//2
alert(c2.getCount());//2   

　　（1）为了解决私有作用域模式中私有数据成员共享的问题，必须将私有数据成员写在MyClass内。但这样，公有成员函数就不能使用他们了。所以还是要使用一个特权函数，提供私有数据成员的接口，这个是无法避免的，因此只能让代价尽量的小，比如对私有数据成员做一个打包。
　　（2）私有方法是内存共享的，比如add函数。然而实际上，私有方法只要共享内存，就是private static状态，而private static状态方法，如果想使用非形参变量时，也只能使用private static的变量，比如_count。想使用实例的私有数据成员，只能通过形参传入。
　　（3）公有方法是内存共享的，是通过原型链实现的。公有方法使用私有数据成员，就必须得到私有数据成员的接口。我们做的this.data就是接口。
　　（4）整个模式中，闭包个数只有一个，就是this.data，这个闭包是无法避免的。