JavaScript高级程序设计——从头学(3)

对象基础

一、OOP

二、对象应用

三、对象的类型

　　3.1 本地对象

　　　　ECMA-262t将本地对象(native object)定义为“独立于宿主环境的ECMAScript实现提供的对象”。简单的来讲，本地对象是ECMA-262定义的类(引用类型)。

　　　　它们包括：

　　　　Object　　　　Function　　Array　　String　　Boolean

　　　　Number　　　Date　　　　 RegExp　Error　　 EvalError

　　　　RangeError   ReferenceError　　SyntaxError    TypeError  　　URIError

　　3.2 内置对象

　　　　ECMA-262把内置对象(built-in object)定义为“由ECMAScript实现提供的、独立于宿主环境的全部对象，在ECMAScript程序开始执行时出现”。

　　　　ECMA-262只定义了两个内置对象：Global 和 Math 。内置对象也是本地对象。

　　　　在ECMAScript中，不存在独立的函数，全部函数都必须是某个对象的方法。

　　　　　　encodeURI():不对URI中的特殊字符进行编码，如冒号、前斜杠、问号和英镑符号。

　　　　　　encodeURIComponent():对它发现的全部非标准字符进行编码。 这两个方法用于编码传递给浏览器的URI。

　　　　　　decodeURI():

　　　　　　decodeURIComponent():

　　　　　　eval():最强大的方法，接受一个参数，即要执行的ECMAScript(或JavaScript)字符串。

　　3.3 宿主对象

　　　　Host Object: 由ECMAScript 实现的宿主环境提供的对象。全部BOM和DOM对象都是宿主对象。

四、做用域

　　变量的适用范围。

　　4.1 公用、受保护和私有做用域

　　　　私有做用域的属性只能在对象内部访问，对于外部世界来讲，这些属性并不存在。这也意味着类定义了私有属性和方法，它的子类也不能访问这些属性和方法。

　　4.2 静态做用域并不是静态的y

　　　　静态做用域定义的属性和方法任什么时候候都能从同一个位置访问。在Java中，类具备静态属性和方法，无需实例化该类的对象，就能够访问这些属性和方法。

　　4.3 关键字this

　　　　this老是指向调用该方法的对象。

　　　　为何使用this呢？由于在实例化对象时，老是不能肯定开发者会使用什么样的变量名。

　　　　使用this能够在多个地方重用同一个函数。

　　　　funtion showColor(){
　　　　　　alert(this.color)

　　　　}

　　　　var oCar1 = new object;

　　　　oCar1.color = "red";

　　　　oCar1.showColor = showColor;

　　　　var oCar2 = new object;

　　　　oCar2.color = "blue";

　　　　oCar2.showColor = showColor;

　　　　oCar1.showColor(); //"red"

　　　　oCar2.showColor();//"blue"

　　　　调用oCar1.showColor()时，this指向oCar1;调用oCar2.showColor()时，this指向oCar2。

　　　　引用对象的属性时，必须使用this关键字。若是不用对象或this引用变量，ECMAScript就会把它看成局部变量或全局变量。

　　　　而后该函数将查找名为color的局部变量或全局变量。

五、定义类或对象

　　1，工厂方式

　　　　对象的属性可在对象建立后动态定义，所以许多开发者在初次引入JavaScript时编写相似下面的代码：

　　　　　　var oCar = new Object();

　　　　　　oCar.color = "red";

　　　　　　oCar.showColor = function () {

　　　　　　　　alert(this.color);

　　　　　　};

　　　　首先，建立对象oCar。而后设置几个属性：颜色。第二个属性是指向函数的指针，意味着该属性是个方法。执行这段代码就能够使用对象oCar.

　　　　问题是可能须要建立多个car实例！！！！

　　　　要解决这个问题，开发者创造了能建立并返回特定类型的对象的工厂函数。

　　　　function createCar(sColor ) {

　　　　　　var oTempCar = new Object();

　　　　　　oTempCar.color = sColor;

　　　　　　oTempCar.showColor = function () {

　　　　　　　　console.log(this.color)

　　　　　　};

　　　　　　return oTempCar;

　　　　};

　　　　var oCar1 = createCar("red");

　　　　var oCar2 = createCar("blue");

　　　　问题是，在重复建立对象时，会存在重复建立函数oTempCar.showColor（）对象的问题。

　　二、构造函数方式

　　　　构造函数看起来很像工厂函数，但构造函数的名字的首字母要大写。构造函数内部无建立对象，而是使用this关键字，所以不须要return一个对象出来。

　　　　function Car(sColor) {

　　　　　　this.color = sColor;

　　　　　　this.showColor = function(){

　　　　　　　　alert(this.color);

　　　　　　};

　　　　};

　　　　问题是，构造函数也会重复生成函数，为每一个对象都建立一个独立的函数。

　　三、原型方式

　　　　利用对象的prototype属性，可把当作建立对象新对象所依赖的原型。用空构造函数来设置类名，而后全部的属性和方法都被直接赋予prototype属性。

　　　　function Car() {

　　　　};

　　　　Car.prototype.color = "red";

　　　　Car.prototype.queue = new Array('Hello');

　　　　Car.prototype.showColor = function() {

　　　　　　console.log(this.color);

　　　　};

　　　　var oCar1 = new Car();

　　　　var oCar2 = new Car();

　　　　首先定义构造函数(Car)，经过给Car的prototype属性添加属性去定义Car 对象的属性。调用new Car()时，原型的全部的属性都被当即赋予要建立的对象。意味着全部Car实例存放的

　　　　都是指向showColor()函数的指针。

　　　　问题是，使用原型方式时，不能经过构造函数传递参数来初始化属性的值。当属性指向对象而不是函数时，会有值得注意的问题。

　　　　oCar1.queue.push("world!");

　　　　console.log(oCar1.queue); //output:【 hello,world!】

　　　　console.log(oCar2.queue);//output:【 hello,world!】

　　四、混合的构造函数/原型方式

　　　　function Car(sColor) {

　　　　　　this.color = sColor;

　　　　　　this.queue = new Array("Hello");

　　　　};

　　　　Car.prototype.showColor = function() {　

　　　　　　console.log(this.color);

　　　　}

　　　　var oCar1 = new Car("red");

　　　　var oCar2 = new Car("blue");

　　　　oCar1.queue.push("world!");

　　　　console.log(oCar1.queue);//['hello','world!']

　　　　console.log(oCar2.queue);//['hello']

　　五、动态原型方法

六、修改对象