摘要：原型繼承與類繼承類繼承是在子類型構(gòu)造函數(shù)的內(nèi)部調(diào)用父類型的構(gòu)造函數(shù)原型式繼承是借助已有的對(duì)象創(chuàng)建新的對(duì)象，將子類的原型指向父類。

js 中實(shí)現(xiàn)繼承有兩種常用方式：

原型鏈繼承（對(duì)象間的繼承）
類式繼承（構(gòu)造函數(shù)間的繼承）

JavaScript不是真正的面向?qū)ο蟮恼Z言，想實(shí)現(xiàn)繼承可以用JS的原型prototype機(jī)制或者call和apply方法

在面向?qū)ο蟮恼Z言中，可以使用類來創(chuàng)建一個(gè)自定義對(duì)象，當(dāng)然ES6中也引入了class來創(chuàng)建類。在這之前，我們需要使用js的原型來創(chuàng)建自定義對(duì)象。

類繼承是在子類型構(gòu)造函數(shù)的內(nèi)部調(diào)用父類型的構(gòu)造函數(shù)

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

function Sub () {
    Super.call(this);
}

原型式繼承是借助已有的對(duì)象創(chuàng)建新的對(duì)象，將子類的原型指向父類。

function Super (id) {
    this.id = id;
}
Super.prototype.toString = function () {
    return "Super" + this.id;
}

function Sub (id) {
    this.id = id;
}

Sub.prototype = new Super();  // 這句即原型式繼承的核心代碼

為了讓子類繼承父類的屬性和方法，首先需要定義一個(gè)構(gòu)造函數(shù)，然后將父類的實(shí)例賦值給構(gòu)造函數(shù)的原型。

function Parent () {
    this.name = "Parent";
}

function Child () {
    this.age = 10;
}
Chid.prototype = new Parent();  // Chid繼承Parent,形成原型鏈

var test = new Child();
console.log(test.name) // Parent
console.log(test.age)  // 10    得到被繼承的屬性

// 繼續(xù)原型鏈繼承
function Brother () {
    this.weight = 60;
}
Brother.prototype = new Child();
var peter = new Brother();
console.log(peter.name)  //繼承了Child和Parent,輸出Parent
console.log(peter.age)  // 輸出10

所有的構(gòu)造函數(shù)都繼承自Object,它是自動(dòng)完成繼承的并不需要我們手動(dòng)繼承，那么接著看它們的從屬關(guān)系

可以通過兩種方式確定原型和實(shí)例的關(guān)系，通過操作符instanceof和isPrototypeof()方法

console.log(peter instanceof Object); //true
console.log(test instanceof Brother)  //false,test是brother的父類
console.log(peter instanceof Child) //true
console.log(peter instanceof Parent)  //true

只要是原型鏈中出現(xiàn)過的原型，都可以說是改原型鏈派生的實(shí)例的原型。因此，isProtptypeof()方法也會(huì)返回true

在JS中，被繼承的函數(shù)成為父類（或者 基類、超類），繼承的函數(shù)成為子類（派生類）。使用原型繼承主要有兩個(gè)問題，一是字面量重寫原型會(huì)中斷關(guān)系，使用引用類型的原型，并且子類型無法給父類型傳遞參數(shù)。

偽類解決引用共享和超類型無法傳參的問題，我們可以采用"類式繼承"的方式

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

function Child (age) {
    Parent.call(this,age);
}

var peter = new Child(20);
console.log(peter.age) //20
console.log(peter.colors) //blue,red,green

peter.colors.push("white");
console.log(peter.colors) //blue,red,green,white

借用構(gòu)造函數(shù)雖然解決了上面兩張問題，但沒有原型，所以我們需要原型鏈+借用構(gòu)造函數(shù)的模式，這種模式成為組合繼承

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

Parent.prototype.run = function () {
    return this.colors + " is " +this.age;
}
function Child (age) {
    Parent.call(this,age);  //對(duì)象冒充，給父類型傳參
}
Child.prototype = new Parent();  //原型鏈繼承

var peter = new Child(20);
console.log(peter.run()); //blue,red,green is 20

組合繼承是一種比較常用的方法，思路是使用原型鏈實(shí)現(xiàn)對(duì)原型屬性和方法的繼承，借用構(gòu)造函數(shù)來實(shí)現(xiàn)對(duì)實(shí)例屬性的繼承。這樣，既實(shí)現(xiàn)了原型上定義方法的函數(shù)復(fù)用，又保證每個(gè)實(shí)例都有自己的屬性。

call()與apply()的用法：調(diào)用一個(gè)對(duì)象的一個(gè)方法，用另一個(gè)對(duì)象替換當(dāng)前對(duì)象。

call(thisObj,Object);  // call接收一個(gè)對(duì)象
apply(thisObj，[argArray])  //apply接收一個(gè)數(shù)組

這種繼承借助原型并基于已有的對(duì)象創(chuàng)建新的對(duì)象，同時(shí)還不用創(chuàng)建自定義類型的方式成為原型式繼承

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

var box = {
        name : "peter",
        arr : ["blue","red","green"]
    };

var b1 = obj(box);
console.log(b1.name) // peter

b1.name = "jack";
console.log(b1.name) //jack

console.log(b1.arr) //blue,red,green
b1.arr.push("white") //blue,red,green,white

var b2 = obj(box);
console.log(b2.name) // peter
console.log(b1.arr) //blue,red,green

原型式繼承首先在obj()函數(shù)內(nèi)部創(chuàng)建一個(gè)臨時(shí)性的構(gòu)造函數(shù)，然后將傳入的對(duì)象作為這個(gè)構(gòu)造函數(shù)的原型，最后返回這個(gè)臨時(shí)類型的新實(shí)例。

這種繼承方式是把原型式+工廠模式結(jié)合起來，目的是為了封裝創(chuàng)建的過程。

function create(o){
        var f = obj(o);
        f.run = function () {
            return this.arr;//同樣，會(huì)共享引用
        };
        return f;
    }

組合式繼承是JS最常用的繼承模式，但組合繼承的父類型會(huì)在使用過程中被調(diào)用兩次，一次是創(chuàng)建子類型的時(shí)候，另一次是在子類型構(gòu)造函數(shù)的內(nèi)部

function Parent(name){
        this.name = name;
        this.arr = ["哥哥","妹妹","父母"];
    }

    Parent.prototype.run = function () {
        return this.name;
    };

    function Child(name,age){
        Parent.call(this,age);//第二次調(diào)用
        this.age = age;
    }

    Child.prototype = new Parent();//第一次調(diào)用

以上代碼是組合繼承，那么寄生組合繼承解決了兩次調(diào)用的問題

function obj() {
    function F() {}
    F.prototype = o;
    return new F();
}
function create(parent,test) {
    var f = obj(parent.prototype); //創(chuàng)建對(duì)象
    f.constructor = test; //增強(qiáng)對(duì)象
}
function Parent(name){
        this.name = name;
        this.arr = ["brother","sister","parents"];
    }

Parent.prototype.run = function () {
        return this.name;
    };

function Child(name,age){
        Parent.call(this,name);
        this.age =age;
    }
inheritPrototype(Parent,Child);  //通過這里實(shí)現(xiàn)繼承

var test = new Child("peter",20);
test.arr.push("new");
console.log(test.arr);  //brother,sister,parents,new
console.log(test.run());  //只共享了方法

var test2 = new Child("jack",22);
console.log(test2.arr);  //引用問題解決

call和apply可以用來改變函數(shù)中this的指向:

// 定義一個(gè)全局函數(shù)
function f () {
    console.log(this.name);
}
// 定義一個(gè)全局變量
var name = "peter";
var obj = {
    name: "jack";
};

f.apply(window); //apple, 此時(shí)this 等于window  相當(dāng)于window.f()
f.apply(obj);  //jack, 此時(shí)this === obj 相當(dāng)于obj.f()