JavaScript 对象

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

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

3. 本地对象
ECMAScript 把本地对象定义为“独立于宿主环境的由 ECMAScript 实现提供的对象”。简单的说，本地对象就是 ECMAScript 定义的类（引用类型）。他们包括：
[img]http://dl.iteye.com/upload/picture/pic/49815/2c218d7f-7526-3e4e-8ad1-338310175f71.png[/img]

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

Global 对象是 ECMAScript 最特殊的一个对象，因为实际上它根本不存在，但是 ECMAScript 把 isNaN()、isFinite()、parseInt()、parseFloat() 这些都看作是 Global 对象的方法。（把这些都归纳起来当做是某对象的方法，然后把该对象抽象为 Global 对象？？）
Global 对象还有以下属性：
[img]http://dl.iteye.com/upload/picture/pic/49817/acd3c01f-373b-3ef7-8d13-fda5a91d4a9d.png[/img]

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

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

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

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

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 函数版本，[b]事实上每个对象都共享了同一个函数[/b]（？不明）。试图把 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 关键字，同时构造函数也没有显示地声明返回值。
[b]当使用 new 关键字调用构造函数时，在执行第一行代码前会先创建一个对象，只有 this 才能访问该对象，然后可以直接赋予 this 属性。默认情况下，this 是构造函数的返回值。[/b]
就像工厂函数，构造函数也存在着 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. 定义对象的最好方式是：用构造函数方式定义属性，用原型方式定义方法，即混合的构造函数/原型方式。