摘要：思路是，使用原型鏈對原型屬性和方法進行繼承，借用構造函數實現對實例屬性的繼承。注意使用寄生式繼承來為對象添加函數，會由于不能做到函數復用而降低效率，這一點與構造函數模式類似。無論什么情況下都會調用兩次超類型的構造函數。

說明：

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

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 因為在上面重新了 Parent 的原型，而且沒有重新指定 constructor
ming.constructor === Grandpa // true 因為上面沒有重寫 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

問題1. 引用類型的繼承在多個實例之間會共享，無論是原型中添加的屬性還是構造函數中添加的屬性。如：

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

問題2. 在創建子類型的實例中，不能向超類型的構造函數中傳遞參數

可以解決引用類型的繼承在多個實例之間共享的問題
如：

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"

注意：這種情況，為了避免超類型的構造函數(Grandpa)重寫子類型(Parnt)的屬性，應在調用超類型構造函數后，再添加應該在子類型中定義的屬性

問題1. 函數沒有復用，占用內存多。
問題2. 超類型原型中定義的方法，對子類型而言是不可見的，結果只能使用構造函數模式。

有時候也叫偽經典繼承。思路是，使用原型鏈對原型屬性和方法進行繼承，借用構造函數實現對實例屬性的繼承。
如：

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()
}

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

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

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

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

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

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+，Firefox 4+, Safari 5+, Opera 912+, Chrome.

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

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"

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

無論什么情況下都會調用兩次超類型的構造函數。一次是在創建子類型原型的時候，一次是在子類型構造函數內部。
如：

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() // 第一次調用超類型的構造函數 Grandpa()，
// 此時原型上有一個friends屬性(值是["ming"])和name屬性(值undefined,因為沒有傳參)
Parent.prototype.sayHi = function () {
  console.log("hi")
}
var wang = new Parent("wang", 15) // 第二次調用超類型的構造函數 Grandpa()，在 Parent() 函數內部調用，
// 這一步的操作， Parent 的實例 wang 的屬性會覆蓋 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) // 這里沒有調用超類型的構造函數 Grandpa() ，但是這里調用了一個函數內部的構造函數
Parent.prototype.sayHi = function () {
  console.log("hi")
}
var li = new Parent("li", 20) // 調用超類型的構造函數 Grandpa()，在 Parent() 函數內部調用

這種模式的好處是只調用一次 Grandpa() 構造函數，因此避免了在 Parent.prototype 上創建不必要的、多余的屬性。
作者講，開發人員普遍認為寄生組合式繼承是引用類型最理想的繼承范式。

繼承部分全部結束