1. ECMAScript 把对象定义为“属性的无序集合,每个属性存放一个原始值、对象或函数。”
2. 在 ECMAScript 里有三种类型的对象,分别是本地对象、内置对象和宿主对象。
3. 本地对象
ECMAScript 把本地对象定义为“独立于宿主环境的由 ECMAScript 实现提供的对象”。简单的说,本地对象就是 ECMAScript 定义的类(引用类型)。他们包括:
[img]http://dl.iteye.com/upload/picture/pic/49925/2274bdc1-df04-3e73-96a0-4a42a2b36eb8.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/49927/313cd8a4-166b-38e6-a59c-de4f1ac5d83f.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. 定义对象的最好方式是:用构造函数方式定义属性,用原型方式定义方法,即混合的构造函数/原型方式。
2. 在 ECMAScript 里有三种类型的对象,分别是本地对象、内置对象和宿主对象。
3. 本地对象
ECMAScript 把本地对象定义为“独立于宿主环境的由 ECMAScript 实现提供的对象”。简单的说,本地对象就是 ECMAScript 定义的类(引用类型)。他们包括:
[img]http://dl.iteye.com/upload/picture/pic/49925/2274bdc1-df04-3e73-96a0-4a42a2b36eb8.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/49927/313cd8a4-166b-38e6-a59c-de4f1ac5d83f.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. 定义对象的最好方式是:用构造函数方式定义属性,用原型方式定义方法,即混合的构造函数/原型方式。