1.原型鏈繼承
核心： 將父類的實例作為子類的原型
將構造函數的原型設置為另一個構造函數的實例對象，這樣就可以繼承另一個原型對象的所有屬性和方法，可以繼續往上，最終形成原型鏈
父類

// 定義一個動物類 function Animal (name) {// 屬性this.name = name || 'Animal';// 實例方法this.sleep = function(){console.log(this.name + '正在睡覺！');} } // 原型方法 Animal.prototype.eat = function(food) {console.log(this.name + '正在吃：' + food); }; function Cat(){ } Cat.prototype = new Animal(); Cat.prototype.name = 'cat';//　Test Code var cat = new Cat(); console.log(cat.name); console.log(cat.eat('fish')); console.log(cat.sleep()); console.log(cat instanceof Animal); //true console.log(cat instanceof Cat); //true

問題
1.來自原型對象的所有屬性被所有實例共享
2.創建子類實例時，無法向父類構造函數傳參

2.構造函數繼承
使用父類的構造函數來增強子類實例，等于是復制父類的實例屬性給子類（沒用到原型）

function SuperType() {this.colors = ["red", "blue", "green"]; }function SubType() {//繼承SuperTypeSuperType.call(this); }var instance1 = new SubType(); instance1.colors.push("black"); alert(instance1.colors); //"red,blue,green,black" var instance2 = new SubType(); alert(instance2.colors); //"red,blue,green"

特點：
解決了1中，子類實例共享父類引用屬性的問題
創建子類實例時，可以向父類傳遞參數
可以實現多繼承（call多個父類對象）
缺點：
實例并不是父類的實例，只是子類的實例
只能繼承父類的實例屬性和方法，不能繼承原型屬性/方法
無法實現函數復用，每個子類都有父類實例函數的副本，影響性能

3.組合繼承

將原型鏈和借用構造函數的技術組合到一塊。使用原型鏈實現對原型屬性和方法的繼承，而通過構造函數來實現對實例屬性的繼承。

function SuperType(name) {this.name = name;this.colors = ["red", "blue", "green"]; }SuperType.prototype.sayName = function() {alert(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() {alert(this.age); };var instance1 = new SubType("Nicholas", 29); instance1.colors.push("black"); alert(instance1.colors); //"red,blue,green,black" instance1.sayName(); //"Nicholas"; instance1.sayAge(); //29 var instance2 = new SubType("Greg", 27); alert(instance2.colors); //"red,blue,green" instance2.sayName(); //"Greg"; instance2.sayAge(); //27

將SubType的原型指定為SuperType的一個實例，大致步驟和原型鏈繼承類似，只是多了在SubType中借調SuperType的過程。
實例屬性定義在構造函數中，而方法則定義在構造函數的新原型中，同時將新原型的constructor指向構造函數。
可以通過instanceof和isPrototypeOf()來識別基于組合繼承創建的對象。
避免了原型鏈和借用構造函數的缺陷，融合了它們的優點，成為JS中最常用的繼承模式。

4.原型式繼承
不自定義類型的情況下，臨時創建一個構造函數，借助已有的對象作為臨時構造函數的原型，然后在此基礎實例化對象，并返回。

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

本質上是object()對傳入其中的對象執行了一次淺復制

var person = {name: "Nicholas",friends: ["Shelby", "Court", "Van"] };var anotherPerson = object(person); anotherPerson.name = "Greg"; anotherPerson.friends.push("Rob");var yetAnotherPerson = object(person); yetAnotherPerson.name = "Linda"; yetAnotherPerson.friends.push("Barbie");alert(person.friends); //"Shelby,Court,Van,Rob,Barbie"

原型的引用類型屬性會在各實例之間共享。
當只想單純地讓一個對象與另一個對象保持類似的情況下，原型式繼承是完全可以勝任的。

5.寄生組合式繼承
組合繼承是JS中最常用的繼承模式，但其實它也有不足，組合繼承無論什么情況下都會調用兩次超類型的構造函數，并且創建的每個實例中都要屏蔽超類型對象的所有實例屬性。
寄生組合式繼承就解決了上述問題，被認為是最理想的繼承范式。

function object(o) {function F(){}F.prototype = o;return new F(); }function inheritPrototype(superType, subType) {var prototype = object(superType.prototype);prototype.constructor = subType;subType.prototype = prototype; }function SuperType(name) {this.name = name;this.colors = ["red", "blue", "green"]; }SuperType.prototype.sayName = function() {alert(this.name); };function SubType(name, age) {SuperType.call(this, name);this.age = age; }inheritPrototype(SuperType, SubType); // 這一句，替代了組合繼承中的SubType.prototype = new SuperType()SubType.prototype.sayAge = function() {alert(this.age); };

不必為了指定子類型的原型而調用超類型的構造函數，我們需要的只不過是超類型原型的一個副本
在inheritPrototype()函數中所做的事:

1.在inheritPrototype函數中用到了原型式繼承中的object()方法，將超類型的原型指定為一個臨時的空構造函數的原型，并返回構造函數的實例。

2.此時由于構造函數內部為空（不像SuperType里面有實例屬性），所以返回的實例也不會自帶實例屬性，這很重要！因為后面用它作為SubType的原型時，就不會產生無用的原型屬性了，借調構造函數也就不用進行所謂的“重寫”了。

3.然后為這個對象重新指定constructor為SubType，并將其賦值給SubType的原型。這樣，就達到了將超類型構造函數的實例作為子類型原型的目的，同時沒有一些從SuperType繼承過來的無用原型屬性。

本面試題為前端常考面試題，后續有機會繼續完善。我是歌謠，一個沉迷于故事的講述者。

歡迎一起私信交流。

“睡服“面試官系列之各系列目錄匯總（建議學習收藏）?

總結

以上是生活随笔為你收集整理的“约见”面试官系列之常见面试题第三十八篇之js常见的继承方式（建议收藏）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。