JavaScript 对象

1. ECMAScript 把对象定义为“属性的无序集合，每个属性存放一个原始值、对象或函数。”

2. 在 ECMAScript 里有三种类型的对象，分别是本地对象、内置对象和宿主对象。

3. 本地对象
    ECMAScript 把本地对象定义为“独立于宿主环境的由 ECMAScript 实现提供的对象”。简单的说，本地对象就是 ECMAScript 定义的类（引用类型）。他们包括：


4. 内置对象
    ECMAScript 把内置对象定义为“独立于宿主环境的由 ECMAScript 实现提供，并且在 ECMAScript 程序执行时就已经出现的对象”。这意味着开发者不必明确实例化内置对象，它已经被实例化了。ECMAScript 只定义了两个内置对象，即 Global 和 Math（它们也是本地对象，根据定义，ECMAScript 每个内置对象都是本地对象）。

    Global 对象是 ECMAScript 最特殊的一个对象，因为实际上它根本不存在，但是 ECMAScript 把 isNaN()、isFinite()、parseInt()、parseFloat() 这些都看作是 Global 对象的方法。（把这些都归纳起来当做是某对象的方法，然后把该对象抽象为 Global 对象？？）
Global 对象还有以下属性：


5. 宿主对象
    所有非本地对象都是宿主对象，即由 ECMAScript 宿主环境实现提供的对象。所有的 BOM 对象和 DOM 对象。

6. 作用域
    与 Java 程序设计语言不同，ECMAScript 只存在一种作用域——公用作用域。即 ECMAScript 对象的所有属性和方法都是公用的。

7. this 关键字
    与 Java 一样，this 关键字总是指向调用该方法的对象。

8. 定义对象
    预定义对象是面向对象编程语言能力的一部分，它的真正强大之处在于能够创建自己的专业类和对象。
    注意，ECMAScript 对象的属性可在对象创建后动态定义，如：

    var oCar = new Object;
    oCar.color = "red";
    oCar.doors = 4;
    oCar.showColor = function(){
        alert(this.color);
    }

9. 工厂方式创建对象

    function createCar(){
        var oCar = new Object;
        oCar.color = "red";
        oCar.doors = 4;
        oCar.showColor = function(){
            alert(this.color);
        }
        return oCar;
    }
    var oCar1 = createCar();
    var oCar2 = createCar();

    修改 createCar 函数，给它传递各属性的默认值：
   
    function createCar(color,doors){
        var oCar = new Object;
        oCar.color = color;
        oCar.doors = doors;
        oCar.showColor = function(){
            alert(this.color);
        }
        return oCar;
    }
    var oCar1 = createCar("red",2);
    var oCar2 = createCar("green",4);

    但是这样存在一个问题，每次调用 createCar 函数都将创建新版本的 showColor 函数，这意味着每个对象都有自己的 showColor 函数版本，事实上每个对象都共享了同一个函数（？不明）。试图把 showColor 函数提出去：

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

    function createCar(color,doors){
        var oCar = new Object;
        oCar.color = color;
        oCar.doors = doors;
        oCar.showColor = showColor;
        return oCar;
    }
    var oCar1 = createCar("red",2);
    var oCar2 = createCar("green",4);

    这样在创建对象是赋予 oCar 对象一个指向 showColor 函数的指针。从功能上讲，解决了 showColor 的重复创建问题，但是该函数看起来不像是对象 oCar 对象的方法，由此引出了构造函数。

10. 构造函数
        
    function Car(color,doors){
        this.color = color;
        this.doors = doors;
        this.showColor = function(){
            alert(this.color);
        }
    }
    var oCar1 = new Car("red",2);
    var oCar2 = new Car("green",4);

    其实构造函数方式跟工厂方式很相像，不过它们有以下的区别：构造函数内部没有创建对象，而是使用 this 关键字，同时构造函数也没有显示地声明返回值。
    当使用 new 关键字调用构造函数时，在执行第一行代码前会先创建一个对象，只有 this 才能访问该对象，然后可以直接赋予 this 属性。默认情况下，this 是构造函数的返回值。
    就像工厂函数，构造函数也存在着 showColor 函数重复创建的问题，于是引出了原型方式。

11. 原型方式
    该方式利用了对象的 prototype 属性。prototype 是一个特殊的属性，其实是一个对象，可把它看作是创建新对象时所依赖的原型。

    function Car(){
    }

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

    var oCar1 = new Car();
    var oCar2 = new Car();
   
    当调用 new Car() 创建对象是，原型的所有属性都被立即赋予要创建的对象。这意味着所有创建的 Car 对象实例保存的都是 showColor 函数的指针，这就解决了函数重复创建的问题，同时所有属性都属于一个对象，这看起来更像是一个对象的封装。于是解决了前两种方式的两个问题。
    其实以上方式还存在问题，如构造函数没有参数，真正的问题是，当属性指向的是对象而不是函数时。看以下代码：

    function Car(){
    }

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

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

    问题发生：
    oCar1.push("Matt");
    alert(oCar1.dirvers); // output :  "Mike","Sue","Matt"
    alert(oCar2.dirvers); // output :  "Mike","Sue","Matt"

    可以看到 oCar2 的 drivers 属性也多了 "Matt"。因为 oCar1 和 oCar2 的 drivers 属性都是 Car 的原型属性，这是问题的根本。
 
12. 混合的构造函数/原型方式

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

    oCar.prototype.showColor = function(){
        alert(this.color);
    }
  
    var oCar1 = new Car();
    var oCar2 = new Car();

    oCar1.push("Matt");
    alert(oCar1.dirvers); // output :  "Mike","Sue","Matt"
    alert(oCar2.dirvers); // output :  "Mike","Sue"
  
    问题解决。

13. 动态原型方式
   
    function Car(color,doors){
        this.color = color;
        this.doors = doors;
        this.dirvers = new Array("Mike","Sue");
        if(typeof Car._initialed == undefined){
            Car.prototype.showColor = function(){
                alert(this.color);
            }
            Car._initialed = true;
         }
    }

14. 定义对象的最好方式是：用构造函数方式定义属性，用原型方式定义方法，即混合的构造函数/原型方式。