摘要：思路是，使用原型鏈對(duì)原型屬性和方法進(jìn)行繼承，借用構(gòu)造函數(shù)實(shí)現(xiàn)對(duì)實(shí)例屬性的繼承。注意使用寄生式繼承來(lái)為對(duì)象添加函數(shù)，會(huì)由于不能做到函數(shù)復(fù)用而降低效率，這一點(diǎn)與構(gòu)造函數(shù)模式類似。無(wú)論什么情況下都會(huì)調(diào)用兩次超類型的構(gòu)造函數(shù)。

說(shuō)明：

此摘要筆記系列是我最近看《JavaScript高級(jí)程序設(shè)計(jì)(第3版)》隨手所記。
里面分條列舉了一些我認(rèn)為重要的、需要記下的、對(duì)我有幫助的點(diǎn)，是按照我看的順序來(lái)的。
摘要筆記本身沒(méi)有系統(tǒng)性，沒(méi)有全面性可言，寫在這里供有一定基礎(chǔ)的前端開(kāi)發(fā)者參考交流。
里面的知識(shí)點(diǎn)、例子大部分來(lái)源于本書，或者延伸出來(lái)的，都經(jīng)過(guò)我的測(cè)試是對(duì)的，但是沒(méi)辦法保證100%正確，如果有人看到錯(cuò)誤的地方，希望指出來(lái)，謝謝。

function Grandpa () {
  this.name = "Grandpa"
}
Grandpa.prototype.sayName = function () {
  console.log(this.name)
}
function Parent () {
  this.name = "Parent"
}
Parent.prototype = new Grandpa()
Parent.prototype.sayHello = function () {
  console.log("hello")
}
var ming = new Parent()
var li = new Parent()
ming.sayName() // "Parent"
ming.sayHello() // "hello"
ming.sayHello === li.sayHello // true
ming.sayName === li.sayName // true
ming instanceof Parent // true
ming instanceof Grandpa // true
ming.constructor === Parent // false 因?yàn)樵谏厦嬷匦铝?Parent 的原型，而且沒(méi)有重新指定 constructor
ming.constructor === Grandpa // true 因?yàn)樯厦鏇](méi)有重寫 Grandpa 的原型
ming.__proto__ === Parent.prototype // true
ming.__proto__ === Grandpa.prototype // false
Parent.prototype.__proto__ === Grandpa.prototype // true

兩種方法： instanceof 操作符和 isPrototypeOf(),
如上例：

Parent.prototype.isPrototypeOf(ming) // true
Grandpa.prototype.isPrototypeOf(ming) // true
Object.prototype.isPrototypeOf(ming) // true

問(wèn)題1. 引用類型的繼承在多個(gè)實(shí)例之間會(huì)共享，無(wú)論是原型中添加的屬性還是構(gòu)造函數(shù)中添加的屬性。如：

function Grandpa () {
  this.friends = ["ming", "li"]
}
function Parent () {
}
Parent.prototype = new Grandpa()
var ming = new Parent()
var li = new Parent()
ming.friends.push("wang")
console.log(ming.friends) // ["ming", "li", "wang"]
console.log(li.friends) // ["ming", "li", "wang"]
ming.friends === li.friends // true

問(wèn)題2. 在創(chuàng)建子類型的實(shí)例中，不能向超類型的構(gòu)造函數(shù)中傳遞參數(shù)

可以解決引用類型的繼承在多個(gè)實(shí)例之間共享的問(wèn)題
如：

function Grandpa () {
  this.friends = ["ming", "li"]
}
function Aunt () {
  Grandpa.call(this)
}
var ming = new Aunt()
var li = new Aunt()
ming.friends // ["ming", "li"]
ming.friends.push("wang")
li.friends // ["ming", "li"]
ming.friends // ["ming", "li", "wang"]

如：

function Grandpa (name) {
  this.name = name
}
function Parent (name, age) {
  Grandpa.call(this, name)
  this.age = age
}
var ming = new Parent("ming", 15)
ming.age // 15
ming.name // "ming"

注意：這種情況，為了避免超類型的構(gòu)造函數(shù)(Grandpa)重寫子類型(Parnt)的屬性，應(yīng)在調(diào)用超類型構(gòu)造函數(shù)后，再添加應(yīng)該在子類型中定義的屬性

問(wèn)題1. 函數(shù)沒(méi)有復(fù)用，占用內(nèi)存多。
問(wèn)題2. 超類型原型中定義的方法，對(duì)子類型而言是不可見(jiàn)的，結(jié)果只能使用構(gòu)造函數(shù)模式。

有時(shí)候也叫偽經(jīng)典繼承。思路是，使用原型鏈對(duì)原型屬性和方法進(jìn)行繼承，借用構(gòu)造函數(shù)實(shí)現(xiàn)對(duì)實(shí)例屬性的繼承。
如：

function Grandpa (name) {
  this.name = name
  this.friends = ["li"]
}
Grandpa.prototype.sayName = function () {
  console.log(this.name)
}
function Parent (name, age) {
  Grandpa.call(this, name)
  this.age = age
}
Parent.prototype = new Grandpa()
Parent.prototype.sayAge = function () {
  console.log(this.age)
}
var ming = new Parent("ming", 12)
var wang = new Parent("wang", 15)
ming.name // "ming"
ming.friends // ["li"]
ming.friends.push("zhang")
wang.friends // ["li"]
ming.sayName() // "ming"
ming.sayAge() // 12
ming.sayName === wang.sayName // true
ming.sayAge === wang.sayAge // true
ming instanceof Parent // true
ming instanceof Grandpa // true

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

實(shí)際上，object() 對(duì)傳入其中的對(duì)象執(zhí)行了一次淺拷貝。如：

var person = {
  name: "wang",
  friends: ["li"]
}
var person1 = object(person)
person1.name // "wang"
person1.friends // ["li"]
person1.name = "zhang"
person.name // "wang"
var person2 = object(person)
person1.friends.push("yang")
person2.friends // ["li", "yang"]
person2.friends === person.friends // true
person1.friends === person.friends // true

這種原型式繼承，必須有一個(gè)對(duì)象作為另一個(gè)對(duì)象的基礎(chǔ)。把基礎(chǔ)對(duì)象傳入 object() 函數(shù)，把得到的對(duì)象根據(jù)具體需求做修改即可。
但是別忘了所有得到的對(duì)象引用類型是共享的。

es5 新增了 Object.create() 方法規(guī)范了原型式繼承。

這個(gè)方法接受兩個(gè)參數(shù)，一個(gè)用作新對(duì)象的原型對(duì)象，一個(gè)(可選的)為新對(duì)象定義額外屬性的對(duì)象。
在傳入一個(gè)參數(shù)的情況下， Object.create() 和 object() 的行為相同。
Object.create()的第二個(gè)參數(shù)與 Object.defineProperties() 的第二個(gè)參數(shù)格式相同：每個(gè)屬性都是通過(guò)自己的描述符來(lái)定義的。
這種方式指定的任何屬性都會(huì)覆蓋原型對(duì)象上的同名屬性。
如：

var person = {
  name: "wang",
  friends: ["li"]
}
var person1 = Object.create(person, {
  name: {
    value: "zhang"
  },
  friends: {
    value: ["a", "b"]
  }
})
person1.name // "zhang"
person1.friends // ["a", "b"]
person.friends // ["li"]
// 支持 Object.create() 的瀏覽器有 IE 9+，F(xiàn)irefox 4+, Safari 5+, Opera 912+, Chrome.

寄生式繼承是與原型式繼承緊密相關(guān)的一種思路，和工廠模式類似。如：

function createAnother (original) {
  var clone = object(original)
  clone.sayHi = function () {
    console.log("hi")
  }
  return clone
}
var person = {
  name: "wang",
  friends: ["li"]
}
var person1 = createAnother(person)
person1.friends // ["li"]
person1.sayHi() // "hi"

新的對(duì)象person1不僅具有person的所有屬性和方法，還有自己的 sayHi() 方法。
示范的 object() 函數(shù)不是必須的，任何能夠返回新對(duì)象的函數(shù)都適用于此模式。
注意：使用寄生式繼承來(lái)為對(duì)象添加函數(shù)，會(huì)由于不能做到函數(shù)復(fù)用而降低效率，這一點(diǎn)與構(gòu)造函數(shù)模式類似。

無(wú)論什么情況下都會(huì)調(diào)用兩次超類型的構(gòu)造函數(shù)。一次是在創(chuàng)建子類型原型的時(shí)候，一次是在子類型構(gòu)造函數(shù)內(nèi)部。
如：

function Grandpa (name) {
  this.name = name
  this.friends = ["ming"]
}
Grandpa.prototype.sayName = function () {
  console.log(this.name)
}
function Parent (name, age) {
  Grandpa.call(this, name)
  this.age = age
}
Parent.prototype = new Grandpa() // 第一次調(diào)用超類型的構(gòu)造函數(shù) Grandpa()，
// 此時(shí)原型上有一個(gè)friends屬性(值是["ming"])和name屬性(值undefined,因?yàn)闆](méi)有傳參)
Parent.prototype.sayHi = function () {
  console.log("hi")
}
var wang = new Parent("wang", 15) // 第二次調(diào)用超類型的構(gòu)造函數(shù) Grandpa()，在 Parent() 函數(shù)內(nèi)部調(diào)用，
// 這一步的操作， Parent 的實(shí)例 wang 的屬性會(huì)覆蓋 Parent 的原型上的同名屬性 name

基本模式如下：

function inheritPrototype (subType, superType) {
  var prototype = object(superType.prototype)
  prototype.constructor = subType
  subType.prototype = prototype
}
function Grandpa (name) {
  this.name = name
  this.friends = ["ming"]
}
Grandpa.prototype.sayName = function () {
  console.log(this.name)
}
function Parent (name, age) {
  Grandpa.call(this, name)
  this.age = age
}
inheritPrototype(Parent, Grandpa) // 這里沒(méi)有調(diào)用超類型的構(gòu)造函數(shù) Grandpa() ，但是這里調(diào)用了一個(gè)函數(shù)內(nèi)部的構(gòu)造函數(shù)
Parent.prototype.sayHi = function () {
  console.log("hi")
}
var li = new Parent("li", 20) // 調(diào)用超類型的構(gòu)造函數(shù) Grandpa()，在 Parent() 函數(shù)內(nèi)部調(diào)用

這種模式的好處是只調(diào)用一次 Grandpa() 構(gòu)造函數(shù)，因此避免了在 Parent.prototype 上創(chuàng)建不必要的、多余的屬性。
作者講，開(kāi)發(fā)人員普遍認(rèn)為寄生組合式繼承是引用類型最理想的繼承范式。

繼承部分全部結(jié)束