JavaScript常見的繼承方式

時間 2019-11-07

原文原文鏈接

原型鏈機制

JavaScript將原型鏈做爲實現繼承的主要方法，其基本思想就是利用原型讓一個引用類型繼承另外一個引用類型的屬性和方法。瀏覽器

構造函數和原型還有實例之間的關係：每一個構造函數都有一個原型對象（prototype），原型對象都包含一個指向構造函數的指針（constructor），而實例都包含一個指向原型對象的內部指針 （propto） 。app

其實每個Function都是Object基類的一個實例，因此每個Function上都有一個__proto__指向了Object.prototype。當查找一個實例的屬性時，會先從這個實例的自定義屬性上找，若是沒有的話經過__proto__去實例所屬類的原型上去找，若是尚未的話再經過原型（原型也是對象，只要是對象就有__proto__屬性）的__proto__到Object的原型上去找，一級一級的找，若是沒有就undefined。函數

能夠說引用類型之間的繼承就是經過原型鏈機制實現的。post

繼承方式

1. 原型鏈繼承

這種方式關鍵在於:子類型的原型爲父類型的一個實例對象。性能

//父類型
function Person(name, age) {
   this.name = name,
   this.age = age,
   this.play = [1, 2, 3]
   this.setName = function () { }
}
Person.prototype.setAge = function () { }
//子類型
function Student(price) {
   this.price = price
   this.setScore = function () { }
}
Student.prototype = new Person() // 子類型的原型爲父類型的一個實例對象
var s1 = new Student(15000)
var s2 = new Student(14000)
console.log(s1,s2)
複製代碼

但這種方式實現的本質是經過將子類的原型指向了父類的實例，因此子類的實例就能夠經過__proto__訪問到 Student.prototype 也就是Person的實例，這樣就能夠訪問到父類的私有方法，而後再經過__proto__指向父類的prototype就能夠得到到父類原型上的方法。因而作到了將父類的私有、公有方法和屬性都當作子類的公有屬性ui

子類繼承父類的屬性和方法是將父類的私有屬性和公有方法都做爲本身的公有屬性和方法， 咱們都知道在操做基本數據類型的時候操做的是值，在操做引用數據類型的時候操做的是地址，若是說父類的私有屬性中有引用類型的屬性，那它被子類繼承的時候會做爲公有屬性，這樣子類一操做這個屬性的時候，就會影響到子類二。this

s1.play.push(4)
console.log(s1.play, s2.play)
console.log(s1.__proto__ === s2.__proto__)  //true
console.log(s1.__proto__.__proto__ === s2.__proto__.__proto__)  //true
複製代碼

s1中play屬性發生變化，與此同時，s2中play屬性也會跟着變化。spa

另外注意一點的是， 咱們須要在子類中添加新的方法或者是重寫父類的方法時候，切記必定要放到替換原型的語句以後prototype

function Person(name, age) {
   this.name = name,
   this.age = age
}
Person.prototype.setAge = function () {
   console.log("111")
}
function Student(price) {
   this.price = price
   this.setScore = function () { }
}
// Student.prototype.sayHello = function () { }//在這裏寫子類的原型方法和屬性是無效的，
//由於會改變原型的指向，因此應該放到從新指定以後
Student.prototype = new Person()
Student.prototype.sayHello = function () { }
var s1 = new Student(15000)
console.log(s1)
複製代碼

優勢：3d

很是純粹的繼承關係，實例是子類的實例，也是父類的實例
父類新增原型方法和原型屬性，子類都能訪問到
簡單，易於實現

缺點：

沒法實現多繼承
來自原型對象的全部屬性被全部實例共享
建立子類實例時，沒法向父類構造函數傳參
要想爲子類新增屬性和方法，必需要在Student.prototype = new Person() 以後執行，不能放到構造器中

2. 借用構造函數繼承（經典繼承）

這種方式關鍵在於:在子類型構造函數中通用call()調用父類型構造函數

function Person(name, age) {
    this.name = name,
    this.age = age,
    this.setName = function () {}
}
Person.prototype.setAge = function () {}
function Student(name, age, price) {
    Person.call(this, name, age)  // 至關於: this.Person(name, age)
    /*this.name = name this.age = age*/
    this.price = price
}
var s1 = new Student('Tom', 20, 15000)
複製代碼

這種方式只是實現部分的繼承，若是父類的原型還有方法和屬性，子類是拿不到這些方法和屬性的。

在子類的構造函數中，改變父類的this指向，改變爲子類的實例，同時運行父類方法，這樣父類中的this.x就變成了子類的實例.x ,經過這種方法就能夠繼承了父類的私有屬性，且只能繼承父類的私有屬性和方法。也許你會問那我Person.prototype.call(this) 不就能夠繼承父類的公有屬性和方法麼，我只能默默的說一句，call是Function的方法。

console.log(s1.setAge())//Uncaught TypeError: s1.setAge is not a function
複製代碼

優勢：

解決了原型鏈繼承中子類實例共享父類引用屬性的問題
建立子類實例時，能夠向父類傳遞參數
能夠實現多繼承(call多個父類對象)

缺點：

實例並非父類的實例，只是子類的實例
只能繼承父類的實例屬性和方法，不能繼承原型屬性和方法
沒法實現函數複用，每一個子類都有父類實例函數的副本，影響性能

3. 組合式繼承

這種方式關鍵在於: 經過調用父類構造，繼承父類的屬性並保留傳參的優勢，而後經過將父類實例做爲子類原型，實現函數複用。

function Person(name, age) {
    this.name = name,
    this.age = age,
    this.setAge = function () { }
}
Person.prototype.setAge = function () {
    console.log("111")
}
function Student(name, age, price) {
    Person.call(this,name,age)
    this.price = price
    this.setScore = function () { }
}
Student.prototype = new Person()
Student.prototype.constructor = Student//組合繼承也是須要修復構造函數指向的
Student.prototype.sayHello = function () { }
var s1 = new Student('Tom', 20, 15000)
var s2 = new Student('Jack', 22, 14000)
console.log(s1)
console.log(s1.constructor) //Student
console.log(p1.constructor) //Person
複製代碼

這種方式融合原型鏈繼承和構造函數的優勢，是 JavaScript 中最經常使用的繼承模式。不過也存在缺點就是不管在什麼狀況下，都會調用兩次構造函數：一次是在建立子類型原型的時候，另外一次是在子類型構造函數的內部，子類型最終會包含父類型對象的所有實例屬性，但咱們不得不在調用子類構造函數時重寫這些屬性。

優勢：

能夠繼承實例屬性/方法，也能夠繼承原型屬性/方法
不存在引用屬性共享問題
可傳參
函數可複用

缺點：

調用了兩次父類構造函數，生成了兩份實例

4. 寄生組合式繼承（最完美的繼承方法）

這種方式關鍵在於: 藉助原型能夠基於已有的對象來建立對象，var B = Object.create(A)以A對象爲原型，生成了B對象。B繼承了A的全部屬性和方法。

function Person(name, age) {
    this.name = name,
    this.age = age
}
Person.prototype.setAge = function () {
    console.log("111")
}
function Student(name, age, price) {
    Person.call(this, name, age)
    this.price = price
    this.setScore = function () {}
}
Student.prototype = Object.create(Person.prototype)//核心代碼
Student.prototype.constructor = Student//核心代碼
var s1 = new Student('Tom', 20, 15000)
console.log(s1 instanceof Student, s1 instanceof Person) // true true
console.log(s1.constructor) //Student
console.log(s1)
複製代碼

一樣的，Student繼承了全部的Person原型對象的屬性和方法。目前來講，最完美的繼承方法！

5. ES6中class 的繼承

ES6中引入了class關鍵字，class能夠經過extends關鍵字實現繼承，還能夠經過static關鍵字定義類的靜態方法,這比 ES5 的經過修改原型鏈實現繼承，要清晰和方便不少。

ES5 的繼承，實質是先創造子類的實例對象this，而後再將父類的方法添加到this上面（Parent.apply(this)）。ES6 的繼承機制徹底不一樣，實質是先將父類實例對象的屬性和方法，加到this上面（因此必須先調用super方法），而後再用子類的構造函數修改this。

須要注意的是，class關鍵字只是原型的語法糖，JavaScript繼承仍然是基於原型實現的。

class Person {
    //調用類的構造方法
    constructor(name, age) {
        this.name = name
        this.age = age
    }
    //定義通常的方法
    showName() {
        console.log("調用父類的方法")
        console.log(this.name, this.age);
    }
}
let p1 = new  Person('kobe', 39)
console.log(p1)
//定義一個子類
class Student extends Person {
    constructor(name, age, salary) {
        super(name, age)//經過super調用父類的構造方法
        this.salary = salary
    }
    showName() {//在子類自身定義方法
        console.log("調用子類的方法")
        console.log(this.name, this.age, this.salary);
    }
}
let s1 = new Student('wade', 38, 1000000000)
console.log(s1)
s1.showName()
複製代碼