第6章面向对象的程序设计

最新推荐文章于 2024-04-13 20:15:14 发布

zhouyong80

最新推荐文章于 2024-04-13 20:15:14 发布

阅读量294

点赞数

分类专栏： JavaScript高级编程（第三版）学习笔记文章标签： JavaScript

本文链接：https://blog.csdn.net/zhouyong80/article/details/88093404

版权

JavaScript高级编程（第三版）学习笔记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

面向对象（Object-Oriented，OO）的语言有一个标志，就是他们都有类的概念，而通过类可以创建任意多个具有相同属性的方法和对象。
ECMAScript中没有类的概念，因此它的对象也与基于类的语言中的对象有所不同。
ECMA-262把对象定义为：“无序属性的集合，起属性可以包含基本值、对象或函数”。可以把ECMAScript的对象想象成散列表：无非就是一组名值对，其中值可以是数据或函数。
每个对象都是基于一个引用类型创建的，这个引用类型可以是原生类型，也可以是自定义类型。

理解对象

创建自定义对象的最简单方式就是创建一个Object实例，然后再为它添加属性和方法。

var person = new Object();
person.name = "Nicholas";
person.age = 29;
person.job = "Software Engineer";

person.sayName = function() {
    alert(this.name);
};

推荐使用对象字面量创建对象：

var person = {
    name : "Nicholas",
    age : 29,
    job : "software Engineer",
    
    sayName: function(){
        alert(this.name);
    }
};

属性类型

ECMA-262第五版在定义只有内部才用的特性（attribute）时，描述了属性（property）的各种特征。这些特性是为了实现JavaScript引擎用的，因此在JavaScript中不能直接访问它们。为了表示特性是内部值，该规范把他们放在了两对儿方括号中，例如[[Enumerable]]。
ECMAScript中有两种属性：数据属性和访问器属性。

数据属性
数据属性包含一个数据值的位置。在这个位置可以读取和写入值。数据属性有4个描述其行为的特性。

[[Configurable]]：表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性。直接在对象上定义的属性，他们的这个特性默认值为true。
[[Enumerable]]：表示能否通过for-in循环返回属性。直接在对象上定义的属性，这个特性默认值为true。
[[Writable]]：表示能否修改属性的值。直接在对象上定义的属性，这个特性默认值为true。
[[Value]]：包含这个属性的数据值。读取属性值的时候，从这个位置读；写入属性值的时候，把新值保存在这个闻之。这个特性的默认值为undefined。
修改属性默认的特性，必须使用Object.defineProperty()方法。这个方法接收三个参数：属性所在的对象、属性的名字和一个描述符对象。其中，描述符对象必须是：configurable、emumerable、writable和value。设置其中的一或多个值，可以修改对应的特性值。
一旦把configurable属性定义为不可配置的，就不能再把它变回可配置了。
eg：

var person = {};
Object.defineProperty(person, "name", {
    writable : false,
    value: "Nicholas"
});

alert(person.name);         // “Nicholas”
person.name = "Greg";
alert(person.name);         // "Nicholas"

访问器属性
访问器属性不包含数据值，它们包含对儿getter和setter函数（不过，这两个函数都不是必需的）。
在读取访问器属性时，会调用getter函数，这个函数负责返回有效的值；在写入访问器属性时，会调用setter函数并传入新值，这个函数负责决定如何处理数据。
访问器属性有4个特性。

[[Configurable]]：表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为数据属性。默认值为true。
[[Enumerable]]：表示能否通过for-in循环返回属性，默认值true。
[[Get]]：在读取属性时调用的函数，默认值为undefined。
[[Set]]：在写入属性时调用的函数。默认值为undefined。
访问器属性不能直接定义，必须使用Object.defineProperty()来定义。
eg：

var book = {
    _year: 2004,
    edition: 1
};

Object.defineProperty(book, "year", {
    get: function() {
        return this._year;
    },
    set: function(newValue) {
        if (newValue > 2004) {
            this._year = newValue;
            this.edition += newValue -2004;
        }
    }
});

book.year = 2005;
alert(book.edition);            //2

不一定非要同时制定getter和setter。只制定getter意味着属性只读，尝试写入会被忽略，在严格模式下会抛出错误。只指定了setter的属性不可读，在非严格模式下会返回undefined，在严格模式下会抛出错误。

非标准方法__defineGetter__()和__defineSetter__()方法也可以定义访问器属性。

定义多个属性

Object.defineProperties()方法，可以通过描述符一次定义多个属性。这个方法接收两个对象参数：第一个对象是要添加和修改其属性的对象，第二个对象的属性与第一个对象中药添加或修改的属性一一对应。
eg：

var book = {};

Object.defineProperties(book, {
    _year: {
        value: 2004
    },

    edition: {
        value: 1
    },

    year: {
        get: function() {
            return this._year;
        }

        set: function(newValue) {
            if (newValue > 2004) {
                this._year = newValue;
                this.edition += newValue -2004;
            }
        }
    }
});

读取属性的特性

Object.getOwnPropertyDescriptor()方法，可以取得给定属性的描述符。接收两个参数：属性所在的对象和要读取其描述符的属性名称。返回值是一个对象，如果是访问器属性，这个对象有configurable、enumerable、get和set；如果是数据属性，这个对象的属性有configurable、writable和value。
eg：

var book = {};

Object.defineProperties(book, {
    _year: {
        value: 2004
    },

    edition: {
        value: 1
    },

    year: {
        get: function() {
            return this._year;
        },
        set: function(newValue) {
            if (newValue > 2004) {
                this._year = newValue;
                this.edition += newValue -2004;
            }
        }
    }
});

var descriptor = Object.getOwnPropertyDescriptor(book, "_year");
alert(descriptor.value);        //2004
alert(descriptor.configurable);     //false
alert(typeof descriptor.get);       //"undefined"

var descriptor = Object.getOwnPropertyDescriptor(book, "year");
alert(descriptor.value);            //"undefined"
alert(descriptor.enumerable);       //false
alert(typeof descriptor.get);       //"function"

在JavaScript中，可以针对任何对象——包括DOM和BOM对象，使用Object.getOwnPropertyDescriptor()方法。

创建对象

虽然Object构造函数或对象字面量都可以用来创建单个对象，但这些方式有个明显的缺点：使用同一个接口创建很多对象，会产生大量的重复代码。

工厂模式

工厂模式抽象了创建具体对象的过程。
eg：

function createPerson(name, age, job) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function() {
        alert(this.name);
    };
    return o;
}

var person1 = createPerson("Nicholas", 29, "Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");

构造函数模式

eg：

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function() {
        alert(this.name);
    };
}

var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

构造函数与一般函数创建对象的区别：

没有显式地创建对象；
直接将属性和方法赋给了this对象；
没有return语句。

构造函数名首字母大写。
利用构造函数创建对象，必须使用new操作符。这种方式会经历以下四个步骤：

创建一个新对象；
将构造函数的作用域赋给新对象（因此this指向了新对象）；
执行构造函数中的代码（为新对象添加属性）；
返回新对象。

利用构造函数创建的对象都有一个constructor(构造函数)属性，该属性指向Person:

alert(person1.constructor == Person);       //true
alert(person2.constructor == Person);       //true

创建自定义构造函数的作用是将它的实例标识为一种特定的类型。

将构造函数当作函数
构造函数与其他函数的唯一区别，就在于调用它们的方式不同。任何函数，只要通过new操作符来调用，那它就可以作为构造函数。
eg:

// 当做构造函数使用var person = new Person("Nicholas", 29, "Software Engineer");
person.sayName();       //"Nicholas"

// 作为普通函数调用
Person("Greg", 27, "Doctor");       // 添加到windowwindow.sayName();                   // "Greg"

// 在另一个对象的作用域中调用var o = new Object();
Person.call(o, "Kristen", 25, "Nurse");
o.sayName();        // "Kristen"

当在全局作用域中调用一个函数时，this对象总是指向Global对象（在浏览器中就是window对象）。
可以使用call()（或者apply()）在某个特殊对象的作用域中调用函数。
2. 构造函数的问题
使用构造函数的主要问题，就是每个方法都要在每个实例上重新创建一遍。可以通过把函数定义转移到构造函数外部来解决这个问题。
eg：

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = sayName;
}

function sayName() {
    alert(this.name);
}

这样做的问题是会定义很多全局函数，于是自定义的引用类型就丝毫没有封装性可言了。

原型模式

创建的每个函数都有一个prototype(原型）属性，这个属性是一个指针，指向一个对象，这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。
eg：

function Person(){}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function() {
    alert(this.name);
};

var person1 = new Person();
person1.sayName();          //"Nicholas"

var person2 = new Person();
person2.sayName();          //"Nicholas"

alert(person1.sayName == person2.sayName);          //true

理解原型对象

无论什么时候，只要创建了一个新函数，就会根据一组特定的规则为该函数创建一个prototype属性，这个属性指向函数的原型对象。在默认情况下，所有原型对象都会自动获得一个constructor（构造函数）属性，这个属性包含一个指向prototype属性所在函数的指针。

当调用构造函数创建一个新实例后，也就是说当使用new操作符创建一个对象后，这个实例内部将包含一个指针（内部属性），指向构造函数的原型对象，这个内部属性无法访问，但可以通过isPrototypeOf()方法来确定对象之间是否存在这种关系。

alert(Person.prototype.isPrototypeOf(person1));     //true
alset(Person.prototype.isPrototypeOf(person2));     //true

以上代码通过原型对象的isPrototypeOf()方法测试了两个实例person1和person2，因为它们内部都包含一个指向Person.prototype的指针，因此都返回了true。

ECMAScript5增加了一个新方法，Object.getPrototypeOf()，在所有支持的视线中，这个方法返回[[Prototype]]的值。

alert(Object.getPrototypeOf(person1) == Person.prototype);      //true
alert(Object.getPrototypeOf(person1).name); //"Nicholas"

每当代码读取某个对象的某个属性时，都会执行一次搜索，首先从对象实例本身开始，如果找到了具体给定名字的属性，则返回该值，如果没有找到，则继续搜索指针指向的原型对象，如果找到具体给定名字的属性，则返回该值。

因为原型最初只包含constructor属性，而该属性也是共享的，因此可以通过对象实例访问。

虽然可以通过对象实例访问保存在原型中的值，但不能通过对象实例重写原型中的值。如果我们在实例中添加了一个属性，而该属性与实例原型中的一个属性同名，那我们就在实例中创建该属性，该属性将会屏蔽原型中的那个属性。
eg：

function Person() {
}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
    alert(this.name);
};

var person1 = new Person();
var person2 = new Person();

person1.name = "Greg";
alert(person1.name);        //“Greg"——来自实例
alert(person2.name);        //"Nicholas"——来自原型

使用hasOwnProperty()方法可以检测一个属性是存在于实例中，还是存在于原型中。这个方法继承自Object，只在给定属性存在于对象实例中，才会返回true。
eg：

function Person() {
}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
    alert(this.name);
};

var person1 = new Person();
var person2 = new Person();

alert(person1.hasOwnProperty("name"));      //false

person1.name = "Greg";
alert(person1.name);            //"Greg"——来自实例
alert(person1.hasOwnProperty("name"));      //true

alert(person2.name);            //"Nicholas"——来自原型
alert(person2.hasOwnProperty("name"));      //false

delete person1.name;
alert(person1.name);            //"Nicholas"——来自原型
alert(person1.hasOwnProperty("name"));      //false

原型与in操作符

有两种方式使用in操作符：单独使用和在for-in循环中使用。单独使用是，in操作符会在通过对象能够访问给定属性时返回true，无论该属性存在于实例中还是原型中。
eg:

function Person() {
}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
    alert(this.name);
};

var person1 = new Person();
var person2 = new Person();

alert(person1.hasOwnProperty("name"));      //false
alert("name" in person1);                   //true

person1.name = "Greg";
alert(person1.name);            //"Greg"——来自实例
alert(person1.hasOwnProperty("name"));      //true
alert("name" in person1);                   //true


alert(person2.name);            //"Nicholas"——来自原型
alert(person2.hasOwnProperty("name"));      //false
alert("name" in person2);                   //true

delete person1.name;
alert(person1.name);            //"Nicholas"——来自原型
alert(person1.hasOwnProperty("name"));      //false
alert("name" in person1);                   //true

由于in操作符只要通过对象能够访问到的属性就返回true，hasOwnProperty()只在属性存在于实例中时才返回true，因此只要in操作符返回true而hasOwnProperty()返回false，就可以确定属性是原型中的属性。

for-in循环返回的是所有能够通过对象访问的、可枚举的属性，其中即包括存在于实例中的属性，也包括存在于原型中的属性。屏蔽了原型中不可枚举属性的实例属性也会在for-in循环中返回，因为根据规定，所有开发人员定义的属性都是可枚举的——IE8及更早版本中例外。

要取得对象上所有可枚举的实例属性，可以使用ECMAScript5的Object.keys()方法，该方法接收一个对象作为参数，返回一个包含所有可枚举属性的字符串数组。
eg：

function Person() {
}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function () {
    alert(this.name);
};

var keys = Object.keys(Person.prototype);
alert(keys);                    // "name,age,job,sayName"

var p1 = new Person();
p1.name = "Bob";
p1.age = 31;
var p1keys = Object.keys(p1);
alert(p1keys);                  //"name,age"

如果你想要得到所有实例属性，无论它是否可枚举，都可以使用Objec.getOwnPropertyNames()方法。

var keys = Object.getOwnPropertyNames(Person.prototype);
alert(keys);        //"constructor,name,age,job,sayName"

更简单的原型语法
用一个包含所有属性和方法的对象字面量来重写整个原型对象，eg：

function Person(){}

Person.prototype = {
    name : "Nicholas",
    age : 29;
    job: "Software Engineer",
    sayName : function() {
        alert(this.name);
    }
};

每创建一个函数，就会同时创建它的prototype对象，这个对象也有自动获得constructor属性。
以上例子中的语法，本质上完全重写了默认的prototype对象，（因为使用字面量相当于新建了一个函数），因此constructor属性也就变成了新对象的constructor属性（该属性指向Object构造函数），不在指向Person函数。要让constructor的值重新指向Person，可以使用如下方法：

function Person(){}

Person.prototype = {
    constructor: Person,
    name : "Nicholas",
    age : 29;
    job: "Software Engineer",
    sayName : function() {
        alert(this.name);
    }
};

但是这种方式重设constructor属性，会导致它的[[Enumerable]]特性被设置为true。而默认情况下，原生的constructor属性是不可枚举的。如果JavaScript引擎兼容ECMAScript5，则可以使用Object.defineProperty()方法，重设constructor属性：

function Person(){}

Person.prototype = {
    name : "Nicholas",
    age : 29;
    job: "Software Engineer",
    sayName : function() {
        alert(this.name);
    }
};

// 重设构造函数，只适用于ECMAScript5兼容的浏览器Object.defineProperty(Person.prototype, "constructor", {
    enumerable: false,
    value: Person
});

原型的动态性
实例中的指针仅指向原型，而不是指向构造函数。
eg:

function Person() {
}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function () {
    alert(this.name);
};

//先创建实例var friend = new Person();

//再为原型添加方法
Person.prototype.sayHi = function() {
    alert("hi");
};

friend.sayHi();             //"hi"（没有问题）

根据规则，当调用friend.sayHi()时，会先搜索实例中的同名方法，没有找到，则继续搜索原型中的同名方法，因此可以随时为原型添加属性和方法，并且修改能立即在所有对象实例中反映出来。

构造函数会为实例添加一个指向最初原型的[[prototype]]指针，如果重写原型对象，会切断构造函数与最初原型之间的练习。
eg：

function Person() {
}

var friend = new Person();

//重写原型对象
Person.prototype = {
    constructor: Person,
    name: "Nicholas",
    age: 29;
    job: "Software Engineer",
    sayName : function() {
        alert(this.name);
    }
};

//由于切单了构造函数与最初原型的联系，因此调用出错
friend.sayName();           //error

原生对象的原型
可以像修改自定义对象的原型一样修改原生对象的原型，随时添加方法。（不推荐）
eg：

String.prototype.startsWith = function(text) {
    return this.indexOf(text) == 0;
}

var msg = "Hello world!";
alert(msg.startsWith("Hello"));     //true

原型对象的问题

原型模式中，所有实例在默认情况下都将取得相同的属性值。
当原型中包含引用类型值的属性时，会造成引用被共享，从而导致错误。
eg：

function Person() {
}

Person.prototype = {
    constructor: Person,
    name: "Nicholas",
    age: 29,
    job: "Software Engineer",
    friends: ["Shelby", "court"],
    sayName: function(){
        alert(this.name);
    }
};

var person1 = new Person();
var person2 = new Person();

person1.friends.push("Van");

alert(person1.friends);     //"Shelby,Court,Van"
alert(person2.friends);     //"Shelby,Court,Van"
alert(person1.friends === person2.friends);     //true

组合使用构造函数模式和原型模式

构造函数模式用于定义实例属性，原型模式用于定义方法和共享的属性。eg：

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["Shelby", "Court"];
}

Person.prototype = {
    constructor : Person,
    sayName : function(){
        alert(this.name);
    }
};

var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

person1.friends.push("Van");
alert(person1.friends);         //"Shelby,Count,Van"
alert(person2.friends);         //"shelby,Count"
alert(person1.friends === person2.friends);     //false
alert(person1.sayName === person2.sayName);     //true

以上代码中，通过构造函数定义了name,age,job,friends四个实例属性，然后在原型中定义了sayName()共享方法，这种构造函数与原型混成的模式，是目前ECMAScript中使用最广泛、认同度最高的一种创建自定义类型的方法。

动态原型模式

使用动态原型模式时，不能使用对象字面量重写原型。如果在已经创建了实例的情况下重写原型，会切断现有实例与新原型之间的联系。

function Person(name, age, job) {
    //属性
    this.name = name;
    this.age = age;
    this.job = job;

    //方法
    if(typeof this.sayName != "function") {
        Person.prototype.sayName = function() {
            alert(this.name);
        };
    }
}

var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName();

寄生构造函数模式

基本思想：创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象。
eg：

function Person(name, age, job) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function(){
        alert(this.name);
    };
    return o;
}

var frined = new Person("Nicholas", 29, "Software Engineer");
friend.sayName();           // "Nicholas"

构造函数在不返回值的情况下，默认返回新对象实例。在构造函数末尾添加return语句，可以重写调用构造函数时返回的值。

寄生构造函数模式，返回的对象与构造函数或者与构造函数的原型属性之间没有关系，不能依赖instanceof操作符来确定对象类型。

稳妥构造函数模式

道格拉斯·克罗克福德（Douglas Crockford）发明了JavaScript中的稳妥对象（durable objects）所谓稳妥对象，值的是没有公共属性，而且其方法也不引用this的对象。

稳妥对象最适合在一些安全的环境中（这些环境中会禁止使用this和new），或者在防止数据被其他应用程序（如Mashup程序）改动时使用。

稳妥构造函数遵循与寄生构造函数类型的模式，但有两点不同：一是新创建的对象的实例方法不引用this；二是不使用new操作符调用构造函数。
eg：

function Person(name, age, job) {
    //创建要返回的对象
    var o = new Object();

    //可以在这里定义私有变量和函数
    
    //添加方法
    o.sayName = function() {
        alert(name);
    };

    //返回对象
    return o;
}

以上代码中，除了调用sayName()方法外，没有别的方式可以访问数据成员。即使有其他代码会给这个对象添加方法和数据成员，但也不可能有别的方法访问传入到构造函数中的原始数据。

继承

两种继承方式：接口继承和实现继承。接口继承只继承方法签名，实现继承则继承实际的方法。
ECMAScript只支持依靠原型链来实现的实现继承

原型链

原型链的基本思想：利用原型让一个引用类型继承另一个引用类型的属性和方法。

每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。如果让原型对象等于另一个类型的实例，此时的原型对象将包含一个指向另一个原型的指针，相应地，另一个原型中也包含着一个指向另一个构造函数的指针。假如另一个原型又是另一个类型的实例，那么上述关系依然成立，如此层层递进，就构成了实例与原型的链条。这就是所谓原型链的基本概念。
eg：

function SuperType(){
    this.property = true;
}

SuperType.prototype.getSuperValue = function() {
    return this.property;
};

function SubType() {
    this.subproperty = false;
}

//继承了SuperType
SubType.prototype = new SuperType();

SubType.prototype.getSubValue = function() {
    return this.subproperty;
};

var instance  = new SubType();
alert(instance.getSuperValue());            //true

以上代码实现继承的的本质就是重写原型对象，代之以一个新类型的实例。
instance指向SubType的原型，SubType的原型又指向SuperType的原型。此时的instance.constructor指向SuperType。

通过实现原型链，扩展了原型搜索机制。

别忘记默认的原型
所有引用类型默认都继承了Object，而这个继承也是通过原型链实现的。所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Object.peototype。
一个完整的原型链如下图所示：
确定原型和实例的关系

可以通过两种方式来确定原型和实例之间的关系，一是使用instanceOf操作符，只要用这个操作符来测试实例与原型链中出现过的构造函数，结果就会返回true。

alert(instance instanceof Object);          //true
alert(instance instanceof SuperType);   //true
alert(instance instanceof SubType);     //true

二是使用isPrototypeOf()方法，只要是原型链中出现过的原型，都可以说是该原型链所派生的实例的原型。

alert(Object.prototype.isPrototypeOf(instance));    //true
alert(SuperType.prototype.isPrototypeOf(instance));//true
alert(SubType.prototype.isPrototypeOf(instance));  //true

谨慎地定义方法

子类型有时候需要重写超类型中的某个方法，或者添加超类型中不存在的某个方法，但不管如何，给原型添加方法的代码一定要放在替换原型的语句之后。
eg：

function SuperType(){
    this.property = true;
}

SuperType.prototype.getSuperValue = function() {
    return this.property;
};

function SubType() {
    this.subproperty = false;
}

//继承了SuperType
SubType.prototype = new SuperType();

//添加新方法
SubType.prototype.getSubValue = function() {
    return this.subproperty;
};

//重写超类中的方法
SubType.prototype.getSuperValue = function() {
    return false;
}

var instance  = new SubType();
alert(instance.getSuperValue());            //false

在通过原型链实现继承时，不能使用对象字面量创建原型方法。因为这样做就会重写原型链。

原型链的问题
最主要的问题来自包含引用类型值的原型。
eg：

function SuperType(){
    this.colors = ["red", "blue", "green"];
}

function SubType() {
}

//继承了SuperType
SubType.prototype = new SuperType();

var instance1 = new SubType();
instance1.colors.push("black");
alert(instance1.colors);        //"red,blue,green,black"

var instance2 = new SubType();
alert(instance2.colors);        //"red,blue,green,black"

第二个问题：在创建子类型的实例是，不能向超类型的构造函数中传递参数。实际上，应该说是没有办法在不影响所有对象实例的情况下，给超类型的构造函数传递参数。所以，实践中很少单独使用原型链。

借用构造函数

解决原型中包含引用类型值所带来的问题，使用一种叫做借用构造函数的技术（constructor stealing）（有时候也叫做伪造对象或经典继承）。
基本思想：在子类型构造函数的内部调用超类型构造函数。函数只不过是在特定环境中执行代码的对象，因此通过调用applay()和call()方法也可以再（将来）新创建的对象上执行构造函数。
eg：

function SuperType(){
    this.colors = ["red", "green", "blue"];
}

function SubType(){
    //继承了SuperType
    SuperType.call(this);
}

var instance1 = new SubType();
instance1.colors.push("black");
alert(instance1.colors);        //"red,green,blue,black"

var instance2 = new SubType();
alert(instance2.colors);        //"red,green,blue"

传递参数
相对于原型链，借用构造函数有一个很大的优势：可以再子类型构造函数中向超类型构造函数传递参数。
eg：

function SubType(){
    //继承了SuperType
    SuperType.call(this,"Nicholas");

    //实例属性
    this.age = 29;
}

var instance = new SubType();
alert(instance.name);       //"Nicholas"
alert(instance.age);        //29

以上代码中的SuperType只接受一个参数name。该参数会直接赋给一个属性。在SubType构造函数内部调用superType构造函数时，实际上是为SubType的实例设置了name属性。为了确保SuperType函数不会重写子类型的属性，可以再调用超类型构造函数后，再添加应该在子类型中定义的属性。
2. 借用构造函数的问题
如果仅仅是借用构造函数，那么也将无法避免构造函数模式存在的问题——方法都在构造函数中定义，因此函数复用就无从谈起了。并且，超类型的原型中定义的方法，对子类型而言也是不可见的。

组合继承

组合继承（combination inheritance），也叫做伪经典继承，指的是将原型链和借用构造函数的技术组合到一起。
思路：使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。
eg：

function SuperType(name) {
    this.name = name;
    this.colors = ["red", "blue", "green"];
}

SuperType.prototype.sayName = function() {
    alert(this.name);
};

function SubType(name, age) {
    //继承属性
    SuperType.call(this, name);

    //实例属性
    this.age = age;
}

//继承方法
SubType.prototype = new SuperType();

SubType.prototype.sayAge = function() {
    alert(this.age);
};

var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
alert(instance1.colors);     //"red,blue,green,black"
instance1.sayName();        //"Nicholas"
instance1.sayAge();         //29

var instance2 = new SubType("Greg", 27);
alert(instance2.colors);    //"red,blue,green"
instance2.sayName();        //"Greg"
instance2.sayAge();         //27

组合继承避免了原型链和借用构造函数的缺陷，融合了他们的有点，成为JavaScript中最常用的继承模式。而且，instanceof和isPrototypeOf()也能够用于识别基于组合继承创建的对象。

原型式继承

借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。
eg：

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

在object()函数内部，先创建了一个临时性的构造函数，然后将传入的对象作为这个构造函数的原型，最后返回这个临时类型的一个新实例。从本质上将，object()对传入其中的对象执行了一次浅复制。

eg：

function object(o) {
    function F(){}
    F.prototype = o;
    return new F();
}

var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};

var anotherPerson = object(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");

var yetAnotherPerson = object(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");

alert(person.friends);      //"Shelby, Court,Van,Rob,Barbie"

ECMAScript5通过新增Object.create()方法规范化了原型式继承。这个方法接收两个参数：一个用作新对象原型的对象和（可选的）一个位新对象定义额外属性的对象。在传入一个参数的情况下，Object.create()与object()方法的行为相同。
eg：

var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};

var anotherPerson = Object.create(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");

var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");

alert(person.friends);      //"Shelby, Court,Van,Rob,Barbie"

Object.create()方法的第二个参数与Object.defineProperties()方法的第二个参数格式相同：每个属性都是通过自己的描述符定义的。以这种方式制定的任何属性都会覆盖原型对象上的同名属性。
eg：

var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};

var anotherPerson = Object.create(person, {
    name: {
        value: "Greg"
    }
});
alert(anotherPerson.name);      //"Greg"

支持Object.create()方法的浏览器有IE9+、Firefox4+、Safari5+、Opera12+和Chrome。
在只想让一个对象与另一个对象保持类似的情况下，原型式继承是完全可以胜任的。需要注意的是，包含引用类型值的属性始终会共享相应的值。

寄生式继承

思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真地是它做了所有工作一样返回对象。
eg：

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

function createAnoter(original) {
    var clone = object(original);           // 通过调用函数创建一个新对象
    clone.sayHi = function(){               //以某种方式来增强这个对象
        alert("hi");
    };
    return clone;                           //返回这个对象
}

以上代码中，createAnother()函数接收了一个参数，也就是将要作为新对象基础的对象。然后，把这个对象(original)传递个object()函数，将返回的结构赋值给clone。再为clone对象添加一个新方法sayHi(),最后返回clone对象。

寄生组合式继承

所谓寄生组合式继承，即通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。
思路：不必为了制定子类型的原型而调用超类型的构造函数，我们所需要的无非是超类型原型的一个副本而已。本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果制定给子类型的原型。
eg：

function inheritPrototype(subType, superType) {
    var prototype = object(superType.prototype);        //创建对象
    prototype.constructor = subType;                    //增强对象
    subType.prototype = prototype;                      //指定对象
}

一个完整的寄生组合式继承的例子：

function object(o){
    fuinction F(){}
    F.prototype = o;
    return new F();
}

function inheritPrototype(subType, superType) {
    var prototype = object(superType.prototype);        //创建对象
    prototype.constructor = subType;                    //增强对象
    subType.prototype = prototype;                      //指定对象
}

function SuperType(name) {
    this.name = name;
    this.colors = ["red","blue","green"];
}

SuperType.prototype.sayName = function() {
    alert(this.name);
};

function SubType(name, age) {
    SuperType.call(this, name);
    this.age = age;
}

inheritPrototype(SubType, SuperType);

SubType.prototype.sayAge = function() {
    alert(this.age);
};

zhouyong80

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第6章面向对象的程序设计

面向对象（Object-Oriented，OO）的语言有一个标志，就是他们都有类的概念，而通过类可以创建任意多个具有相同属性的方法和对象。ECMAScript中没有类的概念，因此它的对象也与基于类的语言中的对象有所不同。ECMA-262把对象定义为：“无序属性的集合，起属性可以包含基本值、对象或函数”。可以把ECMAScript的对象想象成散列表：无非就是一组名值对，其中值可以是数据或函数。...
复制链接

扫一扫