JavaScript 继承机制详解：从原型链到寄生组合式

JavaScript 继承概述

JavaScript 继承的概念

在 JavaScript 中，常用的继承方式主要有以下两种：

一是原型链继承（对象间的继承），二是类式继承（构造函数间的继承）。由于 JavaScript 并非像 Java 那样拥有严格的类概念，而是基于对象的语言，因此实现继承主要依赖 JavaScript 的原型 prototype 机制，或者通过 apply 和 call 方法来模拟。

在传统的面向对象语言中，我们通常使用类来创建自定义对象。然而，JavaScript 中万物皆对象，那么如何创建自定义对象呢？这就需要借助 JavaScript 的原型机制。

我们可以将 prototype 简单视为一个模板，新创建的自定义对象都是该模板（prototype）的一个拷贝。实际上，这种拷贝并非物理复制，而是通过链接实现的，只不过这种链接是不可见的。新实例化的对象内部包含一个隐藏的 __Proto__ 指针，指向原型对象。

JavaScript 可以通过构造函数和原型相结合的方式模拟实现类的功能。此外，JavaScript 中类式继承的实现也是基于原型链来完成的。

下面将详细对比原型式继承与类式继承。

类式继承是指在子类型构造函数的内部调用超类型的构造函数。严格的类式继承在实际开发中并不常见，通常是与其他模式组合使用。

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

原型式继承则是借助已有的对象来创建新的对象，将子类的原型指向父类，这就相当于在原型链中加入了父类这条链。

原型链继承

接下来介绍原型链继承。

为了让子类能够继承父类的属性（包括方法），首先需要定义一个构造函数。然后，将父类的新实例赋值给构造函数的原型。代码如下：

<script>
function Parent(){
this.name = 'mike';
    }
function Child(){
 this.age = 12;
 }
 Child.prototype = new Parent();//Child继承Parent，通过原型，形成链条
var test = new Child();
 alert(test.age);
 alert(test.name);//得到被继承的属性
 //继续原型链继承
 function Brother(){ //brother构造
 this.weight = 60;
 }
 Brother.prototype = new Child();//继续原型链继承
 var brother = new Brother();
 alert(brother.name);//继承了Parent和Child,弹出mike
 alert(brother.age);//弹出12
</script>

上述原型链继承还缺少一环，那就是 Object。所有的构造函数都继承自 Object，而继承 Object 是自动完成的，无需手动继承。那么它们之间的从属关系是怎样的呢？

确定原型和实例的关系

可以通过两种方式来确定原型和实例之间的关系：操作符 instanceof 和 isPrototypeOf() 方法。

alert(brother instanceof Object)//true
alert(test instanceof Brother);//false,test 是brother的超类
alert(brother instanceof Child);//true
alert(brother instanceof Parent);//true

只要是原型链中出现过的原型，都可以说是该原型链派生的实例的原型，因此，isPrototypeOf() 方法也会返回 true。

在 JavaScript 中，被继承的函数称为超类型（父类、基类），继承的函数称为子类型（子类、派生类）。使用原型继承主要存在两个问题：一是字面量重写原型会中断关系，二是使用引用类型的原型，并且子类型无法给超类型传递参数。

为了解决引用共享和超类型无法传参的问题，我们可以采用“借用构造函数”技术。

借用构造函数

接下来介绍借用构造函数（类式继承）。

<script>
function Parent(age){
this.name = ['mike','jack','smith'];
this.age = age;
    }
function Child(age){
 Parent.call(this,age);
 }
 var test = new Child(21);
 alert(test.age);//21
 alert(test.name);//mike,jack,smith
 test.name.push('bill');
 alert(test.name);//mike,jack,smith,bill
</script>

虽然借用构造函数解决了前面的两个问题，但由于没有原型，函数的复用就无从谈起。因此，我们需要结合原型链和借用构造函数，这种模式称为组合继承。

组合继承

接下来介绍组合继承。

<script>
function Parent(age){
this.name = ['mike','jack','smith'];
this.age = age;
    }
Parent.prototype.run = function () {
return this.name + ' are both' + this.age;
    };
function Child(age){
Parent.call(this,age);//对象冒充，给超类型传参
    }
Child.prototype = new Parent();//原型链继承
var test = new Child(21);//写new Parent(21)也行
alert(test.run());//mike,jack,smith are both21
</script>

组合式继承是 JavaScript 中最常用的继承方法。其背后的思路是使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数复用，又保证每个实例都有它自己的属性。

call() 的用法：调用一个对象的一个方法，以另一个对象替换当前对象。

call([thisObj[,arg1[, arg2[, [,.argN]]]]])

原型式与寄生式继承

这种继承方式借助原型并基于已有的对象创建新对象，同时不用创建自定义类型，称为原型式继承。

<script>
function obj(o){
function F(){}
F.prototype = o;
return new F();
     }
var box = {
name : 'trigkit4',
arr : ['brother','sister','baba']
    };
var b1 = obj(box);
alert(b1.name);//trigkit4
b1.name = 'mike';
 alert(b1.name);//mike
alert(b1.arr);//brother,sister,baba
 b1.arr.push('parents');
 alert(b1.arr);//brother,sister,baba,parents
var b2 = obj(box);
 alert(b2.name);//trigkit4
 alert(b2.arr);//brother,sister,baba,parents
</script>

原型式继承首先在 obj() 函数内部创建一个临时性的构造函数，然后将传入的对象作为这个构造函数的原型，最后返回这个临时类型的一个新实例。

接下来介绍寄生式继承。

这种继承方式将原型式继承与工厂模式结合起来，目的是为了封装创建的过程。

<script>
function create(o){
var f= obj(o);
f.run = function () {
return this.arr;//同样，会共享引用
        };
return f;
    }
</script>

组合式继承存在一个小问题。

组合式继承是 JavaScript 最常用的继承模式，但组合继承的超类型在使用过程中会被调用两次：一次是创建子类型的时候，另一次是在子类型构造函数的内部。

<script>
function Parent(name){
this.name = name;
this.arr = ['哥哥','妹妹','父母'];
    }
Parent.prototype.run = function () {
 return this.name;
 };
function Child(name,age){
 Parent.call(this,age);//第二次调用
 this.age = age;
 }
Child.prototype = new Parent();//第一次调用
</script>

上述代码展示了之前的组合继承，而寄生组合式继承则解决了调用两次的问题。

寄生组合式继承

接下来介绍寄生组合式继承。

<script>
function obj(o){
function F(){}
F.prototype = o;
return new F();
    }
function create(parent,test){
var f = obj(parent.prototype);//创建对象
f.constructor = test;//增强对象
    }
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);//通过这里实现继承
var test = new Child('trigkit4',21);
 test.arr.push('nephew');
 alert(test.arr);//
 alert(test.run());//只共享了方法
var test2 = new Child('jack',22);
 alert(test2.arr);//引用问题解决
</script>

接下来介绍 call 和 apply。

全局函数 apply 和 call 可以用来改变函数中 this 的指向，如下：

// 定义一个全局函数
function foo() {
console.log(this.fruit);
    }
// 定义一个全局变量
 var fruit = "apple";
 // 自定义一个对象
 var pack = {
 fruit: "orange"
 };
// 等价于window.foo();
 foo.apply(window); // "apple",此时this等于window
 // 此时foo中的this === pack
 foo.apply(pack); // "orange"