JavaScript中定义类或对象

1，对象的构成
对象有特性构成(attribute)，可以是原始值，也可以是引用值。如果特性存放的是函数，它将被看做对象的方法（method），否则该特性被看做属性（property）。
2，定义类或对象
（1）工厂方式

Code
    function createCar(sColor,iDoors) {
        var oTempCar = new Object;
        oTempCar.color = sColor;
        oTempCar.doors = iDoors;
        oTempCar.showColor = function() {
            alert(this.color);
        };
        return oTempCar;
    }

    var oCar1 = createCar("red",4);
    var oCar2 = createCar("blue", 3);
    oCar1.showColor(); //Output "red"
    oCar2.showColor(); //Output "blue"

缺点：
每次调用函数createCar()时，都要创建新函数showColor()，意味着每个对象都有自己的showColor()版本。
改进：

     function  showColor() {
        alert( this .color);
    }

     function  createCar(sColor,iDoors) {
         var  oTempCar  =   new  Object;
        oTempCar.color  =  sColor;
        oTempCar.doors  =  iDoors;
        oTempCar.showColor  =  showColor;

         return  oTempCar;
    }

     var  oCar1  =  createCar( " red " , 4 );
     var  oCar2  =  createCar( " blue " ,  3 );
    oCar1.showColor();
    oCar2.showColor();

但是该函数看起来不像对象的方法。所以就有了构造函数的出现。

（2）构造函数方式  

     function  Car(sColor, iDoors) {
         this .color  =  sColor;
         this .doors  =  iDoors;
         this .showColor  =   function () {
            alert( this .color);
        };
    }

     var  oCar1  =   new  Car( " red " ,  4 );
     var  oCar2  =   new  Car( " blue " ,  3 );

通常构造函数的首字母要大写。
就想工厂函数一样，构造函数也会同样重复生成函数，为每个对象创建独立的函数版本。

（3）原型方式

     function  Car() {
    }

    Car.prototype.color  =   " red " ;
    Car.prototype.doors  =   4 ;
    Car.prototype.showColor  =   function () {
        alert( this .color);
    };

     var  oCar1  =   new  Car();
     var  oCar2  =   new  Car();

缺点：
 原型方式的构造函数没有参数。他不能通过传参来初始化属性的值。还有，当属性指向的是对象时，还会造成对象共享。如下：  

     function  Car() {
    }

    Car.prototype.color  =   " red " ;
    Car.prototype.doors  =   4 ;
    Car.prototype.drivers  =   new  Array( " Mike " ,  " Sue " );
    Car.prototype.showColor  =   function () {
        alert( this .color);
    };

     var  oCar1  =   new  Car();
     var  oCar2  =   new  Car();

    oCar1.drivers.push( " Matt " );

    alert(oCar1.drivers);    // output "Mike,Sue,Matt"
    alert(oCar2.drivers);    // output "Mike,Sue,Matt"

 

（4）混合的构造函数/原型方式

     function  Car(sColor, iDoors) {
         this .color  =  sColor;
         this .doors  =  iDoors;
         this .drivers  =   new  Array( " Mike " ,  " Sue " );
    }

    Car.prototype.showColor  =   function () {
        alert( this .color);
    };

     var  oCar1  =   new  Car( " red " ,  4 );
     var  oCar2  =   new  Car( " blue " ,  3 );

    oCar1.drivers.push( " Matt " );
    
    alert(oCar1.drivers);    // output "Mike,Sue,Matt"
    alert(oCar2.drivers);    // output "Mike,Sue

现在就响创建一般对象一样，所有的非函数属性都在构造函数中创建，而且只创建一个showColor()函数。此外，给oCar1的drivers数组添加“Matt”值，不会影响oCar2的数组。
因此这种方式是ECMAScript采用的主要方式。它具有其他方式的特性，却没有它们的副作用。

（5）动态原型方式

 

     function  Car(sColor, iDoors) {
         this .color  =  sColor;
         this .doors  =  iDoors;
         this .drivers  =   new  Array( " Mike " ,  " Sue " );

         if  ( typeof  Car._initialized  ==   " undefined " ) {
            Car.prototype.showColor  =   function () {
                alert( this .color);
            };

            Car._initialized  =   true ;
        };
    }

 目前使用最广泛的是混合的构造函数/原型方式。此外，动态原型方式也很流行。