js对象和对象继承

对象

ECMA-262把对象定义为“无序属性的集合，其属性可以包含基本值、对象或者函数。” 我们可以吧ECMAScript的对象想象成散列表：无非是一组名值对，其中值可以是数据或者函数。

1
2
3
4
5
6
7
8
var person = new Object()
person.name = "Nicholas"
person.age = 29
person.job = "Software Engineer"

person.sayName = function(){
    console.log(this.name)
}

等价于：

1
2
3
4
5
6
7
8
var person = {
    name: "Nicholas",
    age: 29,
    job: "Software Engineer",
    sayName: function(){
        console.log(this.name)
    }
}

属性类型

ECMAScript中有两种属性：数据属性和访问器属性。

数据

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

  • [[Configurable]]：表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性。上面例子定义的属性，他们的这个特性默认值都为true。
  • [[Enumerable]]：表示能否通过for-in循环返回属性。上面例子定义的属性，他们的这个特性默认值都为true。
  • [[Writable]]：表示能否修改属性的值。上面例子定义的属性，他们的这个特性默认值都为true。
  • [[Value]]：包含这个属性的数据值。读取属性值的时候，从这个位置读；写入属性值的时候，把新值保存在这个位置。默认值为undefined。

要修改默认的特性，必须使用ECMAScript5的Object.defineProperty()方法。这个方法接收三个参数：属性所在的对象、属性的名字和一个描述符(descriptor)对象。其中描述符对象的属性必须是：configurable、enumerable、writable和value。

1
2
3
4
5
6
7
8
9
10
11
var person = {}
Object.defineProperty(person, "name", {
    writable: true,
    value: "Nicholas"
})

person.name // "Nicholas"

person.name = "Greg"

person.name // "Greg"

如果把属性定义为不可配置的，就再也不能把它变成可配置的了。此时再调用Object.defineProperty()方法修改除writable之外的特性，都会导致错误：

1
2
3
4
5
6
7
8
9
10
11
var person = {}
Object.defineProperty(person, "name", {
    configurable: false,
    value: "Nicholas"
})

// 抛出错误
Object.defineProperty(person, "name", {
    configurable: ture, // 
    value: "Nicholas"
})

也就是说，可以多次调用Object.defineProperty()方法修改同一个属性，但在把configurable特性设置为false之后就会有限制了。

访问器属性

访问器属性不包含数据值；它们包含一对getter和setter函数：在读取访问器属性时，会调用getter函数，这个函数负责返回有效的值；在写入访问器属性时，会调用setter函数，这个函数决定如何处理数据。

访问器属性有4个特性：

    • [[Configurable]]：表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性。对于直接在对象上定义的属性，他们的这个特性默认值都为true。
  • [[Enumerable]]：表示能否通过for-in循环返回属性。对于直接在对象上定义的属性，他们的这个特性默认值都为true。
  • [[Get]]：在读取属性时调用的函数。默认为undefined。
  • [[Set]]：在写入属性时调用的函数。默认为undefined。

访问器属性不能直接定义，必须使用Object.defineProperty()来定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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

book.edition // 2

_year前面的下划线是一种常用的符号，用来表示只能通过对象方法访问的属性。

创建对象

工厂模式

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function createPerson(name, age ,job){
    var o = new Object()
    o.name = name
    o.age = age
    o.job = job
    o.sayName = function(){
        console.log(this.name)
    }

    return o
}

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

工厂模式虽然解决了创建多个相似对象的问题，但没有解决对象识别的问题（即怎样知道一个对象的类型）。

构造函数模式

ECMAScript中的构造函数可以用来创建特定类型对象。

1
2
3
4
5
6
7
8
9
10
11
function Person(name, age, job){
    this.name = name
    this.age = age
    this.job = job
    this.sayName = function(){
        console.log(this.name)
    }
}

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

在这个例子中，Person()函数替代了createPerson()函数。Person()函数存在以下不同：

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

要创建一个Person新实例，必须使用new操作符。

new操作符实现原理：见另一篇文章。

将构造函数当作函数

构造函数和其他函数的唯一区别，就在于调用它们的方式不同。任何函数，只要通过new操作符来调用，那它就可以当作构造函数；对任何函数，如果不通过new操作符来调用，就跟普通函数没什么两样。

1
2
3
4
5
6
7
8
9
10
11
// 当作构造函数使用
var person = new Person(...)

// 当作普通函数调用
Person("Greg", 27, "Doctor") // 函数中的this指向window，将属性添加到window
window.sayName() // Greg

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

构造函数的问题

构造函数的主要问题，就是每个方法都要在每个实例上重新创建一遍。

在上面的例子中，person1和person2都有一个名为sayName()的方法，但这两个方法并不是同一个实例。创建两个完成同样任务的Function实例的确没有必要。因此可以使用原型模式来解决。

原型模式

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

使用原型对象的好处是可以让所有对象实例共享它包含的属性和方法，即不必在构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function Person(){

}

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

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

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

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

理解原型对象

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

拿前面的例子来说： Person.prototype.construtor 指向 Person

当调用构造函数创建一个新实例后，该实例的内部包含一个指针(内部属性[[prototype]]——在Firefox、safari、和Chrome中为__proto__，指向构造函数的原型对象。

如果我们在实例中添加了一个属性，而该属性与实例原型中的一个属性同名，那我们就在实例中创建该属性，该属性将会屏蔽原型中的那个属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function Person(){

}

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

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

person1.name = "Greg"

person1.name // "Greg" —— 来自实例
person2.name // "Nicholas" —— 来自原型

当为对象实例添加一个属性时，这个属性就会屏蔽原型对象中保存的同名属性。即这个属性只会阻止我们访问原型中的那个属性，但不会修改哪个属性。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function Person(){

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

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

person1.hasOwnProperty("name") // false

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

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

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

原型与in操作符

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
function Person(){

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

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

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

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

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

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

同时使用hasOwnProperty()方法和in操作符，就可以确定该属性到底是存在于对象中，还是存在于原型中。可以定义一个判断该属性是否只存在原型对象中：

1
2
3
function hasPrototypeProperty(object, name){
    return !object.hasOwnProperty(name) && (name in object)
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function Person(){

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

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

var p1 = new Person()
p1.name = "Rob"
p1.age = 31
var p1keys = Object.keys(p1)
console.log(p1keys) // "name, age"

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

1
2
3
var keys = Object.getOwnPropertyNames(Person.prototype)

console.log(keys) // "constructor, name, age, job"

原型的动态性

在原型中查找值的过程是一次搜索。

1
2
3
4
5
6
7
var friend = new Person()

Person.prototype.sayHi = function(){
    console.log('hi')
}

friend.sayHi() // 'hi'

即使friend实例是在添加新方法之前创建的，但它们仍然可以访问这个新方法。其原因可以归结为实例与原型之间的松散连接关系。

而当重写整个原型对象时，就切断了构造函数与最初原型之间的联系。

实例中的指针仅指向原型，而不指向构造函数。

1
2
3
4
5
6
7
8
9
10
var friend = new Person()
Person.prototype = {
    constructor: Person,
    name: "Nicholas",
    sayName:function(){
        console.log(this.name)
    }
}

friend.sayName() // Error

原生对象的原型

所有原生引用类型（Object、Array、String，等等）都在其构造函数的原型上定义了方法。

1
2
console.log(Array.prototype.sort) // "function"
console.log(String.prototype.substring) // "function"

通过原生对象的原型，不仅可以取得所有默认方法的引用，而且可以定义新方法。

1
2
3
4
5
6
7
String.prototype.startsWith = function(text){
    return this.indexOf(text) === 0
}

var msg = "Hello World"

msg.startsWith("Hello") // ture

原型对象的问题

原型中所有的属性是被很多实例共享的，这种共享对于函数来说非常合适，但对于包含引用类型的属性来说，问题就比较突出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var friend = new Person()
Person.prototype = {
    constructor: Person,
    name: "Nicholas",
    friend: ["Shelby", "Court"],
    sayName:function(){
        console.log(this.name)
    }
}
var person1 = new Person()
var person2 = new Person()

person1.friend.push("Van")

console.log(person1.friend) // "Shelby", "Court", "Van"
console.log(person2.friend) // "Shelby", "Court", "Van"

由于friend数组存在于Person.prototype而非 person1中，所以对于person1.friend的修改也会通过person2.friend反映出来。

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

创建自定义类型最常见的方式，就是组合使用构造函数于原型模式。构造函数用户定义实例属性，而原型模式用于定义方法和共享的属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
function Person(name, age, job){
    this.name = name
    this.age = age
    this.job = job
    this.friends = ["Shelby", "Court"]
}

Person.prototype = {
    constructor: Person.
    sayName: function(){
        console.log(this.name)
    }
}

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

person1.friends.push("Van")

console.log(person1.friend) // "Shelby", "Court", "Van"
console.log(person2.friend) // "Shelby", "Court"

person1.friends === person2.friends // false
person1.sayName === person2.sayName // true

动态原型模式

1
2
3
4
5
6
7
8
9
10
11
12
13
function Person(name, age, job){
    // 属性 
    this.name = name
    this.age = age
    this.job = job
    // 方法
    // 只有在sayName()方法不存在的情况下，才会将它添加到原型中。
    if(typeof this.sayName != 'function'){
        Person.prototype.sayName = function(){
            console.log(this.name)
        }
    }
}

这段代码只会在初次调用构造函数的时候才会执行，此后，原型已经完成初始化，不需要再做什么修改了。 这里对原型所做的修改，能够立即在所有实例中得到反映。

使用动态原型模式时，不能使用对象字面量重写原型。

寄生(parasitic)构造函数模式

这种模式的基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象；但从表面上看，这个函数又很像典型的构造函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function Person(name, age, job){
    var o = new Object();
    o.name = name
    o.age = age
    o.job = job
    o.sayName = function(){
        console.log(this.name)
    }

    return o
}

var friend = new Person("Nicholas", 29, "Software Engineer") // 使用 new 操纵符

friend.sayName() // Nicholas

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

这种模式可以在特殊情况下用来为对象创建构造函数。假设我们像创建一个具有额外方法的特殊数组。由于不能直接修改Array构造函数，因此我们使用这个模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function SpecialArray(){
    // 创建数组
    var values = new Array()
    // 添加值
    values.push.apply(values, arguments)

    // 添加方法
    values.toPipedString = function(){
        return this.join("|")
    }

    // 返回数组

    return values

}

var colors = new SpecialArray("red", "blue", "green")

colors.toPipedString() // "red|blue|green"

有一点需要说明：首先，返回的对象与构造函数或者与构造函数的原型属性之间没有关系，也就是说，构造函数返回的对象与在构造函数外部创建的对抗没有什么不同。因此不能依赖 instanceof来确定对象类型。

稳妥构造函数模式

所谓稳妥对象，指的是没有公共属性，而且其方法也不引用this的对象。 适合在一些安全的环境中（禁止使用this和new）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

function Person(name, age, job){

    // 创建要返回的对象
    var o = new Object()

    // 可以在这里定义私有变量和函数

    o.sayName = function(){
        console.log(name) // 不引用this
    }

    return o
}

var friend = Person("Nicholas", 29, "Software Engineer")

friend.sayName() // "Nicholas"

这样变量friend保存的是一个稳妥对象，而除了调用sayName()方法外，没有别的方式可以访问其数据成员。

继承

实现继承主要是依靠原型链来实现的。

原型链

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

构造函数、原型和实例的关系：每个构造函数都有一个原型对象，原型对象包含一个指向构造函数的指针，而实例都包含一个指向原型对象的指针。

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

代码大致如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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()

console.log(instance.getSuperValue()) // true

实现的本质是重写原型对象，代之以一个新类型的实例。换句话说，原来存在与SuperType的实例的所有属性和方法，现在也存在于SubType.prototype中了。

要注意 instance.constructor现在指向的是SuperType，这是因为SubType.prototype中的constructor被重写的缘故。

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

别忘记默认的原型

所有引用类型默认都继承了Object，而这个继承也是通过原型链实现的。

所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Objcet.prototype。所以所有自定义类型都会继承toString()、valueOf()等默认方法的根本原因。

确定原型和实例的关系

使用instanceof操作符，只用用这个操作符来测试实例与原型链中出现过的构造函数，结果就会返回true。

  • instanceof 底层如何工作
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    function instanceof(L,R){
        var O = R.prototype //获取构造函数的显性原型对象
        var L = L.__proto__ // 获取实例的隐形原型对象
        
        while(true){
            if(L === null){ // 遍历完原型链仍未匹配
                return false
            }
            if(L === O){ // 当显性原型严格等于隐形原型时，返回true
                return true
            }

            L = L.__proto__ // 向上遍历原型链
        }
    }

谨慎定义方法

给原型添加的代码一定要放在替换原型的语句后。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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()

console.log(instance.getSuperValue()) // false

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

原型的问题

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function SuperType(){
    this.colors = ["red","blue","green"]
}

function SubType(){

}

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

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

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

当SubType 通过原型链继承了SuperType 之后，SubType.prototype就变成了SuperType的一个实例，因此它也用了一个它自己的colors属性——就跟专门创建了一个SubType.prototype.colors属性一样。所以SubType的所有实例都会共享这一个colors属性。

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

因为new出来的实例是赋值给SubType.prototype，若该实例的属性值因为参数的不同发生变化，那么会导致SubType.prototype中的属性值也发生变化，会影响到SubType的其他对象实例。

因此在实践中很少会单独使用原型链。

借用构造函数

通过使用apply()或call()方法在新创建的对象上执行构造函数。

1
2
3
4
5
6
7
8
function SuperType(){
    this.colors = ["red"]
}

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

等价于：

1
2
3
4
5
6
7
8
9
function SuperType(){
    this.colors = ["red"]
}

function SubType(){
    // 继承了SuperType
    // SuperType.call(this)
    this.colors = ["red"]
}

传递参数

借用构造函数可以在子类型构造函数中向超类型构造函数传递参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function SuperType(name){
    this.name = name
}

function SubType(){
    // 继承SuperType并传递参数
    SuperType.call(this,"Nicholas")

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

var instance = new SubType()

console.log(instance.name) // "Nicholas"
console.log(instance.age) // 29

// 由于并没有涉及到原型链，因此该实例并不是SuperType的一个实例
console.log(instance instanceof SuperType) // false

借用构造函数的问题

方法都在构造函数中定义，因此函数复用也就无从谈起。而且在超类型原型中定义的方法，对子类型而言也是不可见的，结果所有类型都只能使用构造函数模式。所以实际中也很少单独使用。

组合继承

组合继承将原型链和借用构造函数的技术组合到一块。思路是使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型链上定义方法实现了函数复用，又能够保证每个实例都有它自己的属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
function SuperType(name){
    this.name = name
    this.colors = ["red","blue"]
}

SuperType.prototype.sayName = function(){
    console.log(this.name)
}

function SubType(name, age){
    // 属性继承使用构造函数
    SuperType.call(this, name)
    this.age = age
}

// 方法继承用原型链方式（为了函数复用）
SubType.prototype = new SuperType()
SubType.prototype.constructor = SubType
SubType.prototype.sayAge = function(){
    console.log(this.age)
}

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

var instance2 = new SubType("Greg", 27)
console.log(instance2.colors) // "red, blue"
instance2.sayName() // "Greg"
instance2.sayAge() // 27

组合继承上JS中最常用的继承模式，而且instanceof() 和isPrototypeof()也能识别基于组合继承创建的对象。

原型式继承

基于已有的对象创建新对象，同时还不必因此创建自定义类型。

1
2
3
4
5
function object(o){
    function F(){}
    F.prototype = o
    return new F()
}

object()对传入其中的对象进行了一次浅复制。

ES5通过新增的Object.create()方法规范了原型式继承。该方法接收两个参数：一个用作新对象原型的对象和（可选）一个为新对象定义额外属性的对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court"]
}

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

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

console.log(person.friends) // "Shelby", "Court","Rob","Barbie"

在没有必要兴师动众地创建构造函数，而只是想让一个对象与另一个对象保持类似的情况下，原型式继承完全可以胜任。但是包含引用类型值的属性始终都会共享相应的值，就像使用原型模式一样。

寄生式继承

寄生式继承和原型式继承紧密相关。

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

1
2
3
4
5
6
7
8
function creatAnother(original){
    var clone = object(original) // 通过调用函数创建一个新对象
    clone.sayHi = function(){ // 以某种方式来增强这个对象
        console.log("Hi")
    }

    return clone // 返回这个对象
}

在主要考虑对象而不是自定义类型和构造函数的情况下，寄生式继承也是一种有用的模式。

寄生组合式继承

组合继承有一点不足：组合继承最大的问题就是无论在什么情况下，都会调用两次超类型构造函数：一次是在创建子类型原型的时候(new SuperType())，一次是在子类型构造函数内部(SuperType.call( this ))

调用两次SuperType构造函数会让SubType有两组name和colors属性，一组在实例上，一组在SubType.prototype中。

通过寄生组合式继承可以解决这个问题：

我们无需为了指定子类型的原型而调用超类型的构造函数，我们所需的只是超类型的原型的一个副本，因此我们可以用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。

1
2
3
4
5
function inheritPrototype(SubType, SuperType){
    var prototype = object(SuperType.prototype) //创建对象
    prototype.constructor = SubType //增强对象
    SubType.prototype = prototype // 指定对象
}