JavaScript的继承

继承

• 原型链

其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法

简单回顾一下构造函数、原型和实例的关系:每 个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型 对象的内部指针。那么，假如我们让原型对象等于另一个类型的实例，结果会怎么样呢?显然，此时的 原型对象将包含一个指向另一个原型的指针，相应地，另一个原型中也包含着一个指向另一个构造函数 的指针。假如另一个原型又是另一个类型的实例，那么上述关系依然成立，如此层层递进，就构成了实 例与原型的链条。这就是所谓原型链的基本概念。

实现原型链有一种基本模式，其代码大致如下

    function SuperType() {
        this.prototype = true;
    }

    SuperType.prototype.getSuperValue = function () {
        return this.prototype;
    }

    function SubType() {
        this.subproperty = false;
    }

    //继承supertype
    SubType.prototype = new SuperType();
    SubType.prototype.getSubValue = function () {
        return this.subproperty;
    }

    var instance = new SubType();
    alert(instance.getSuperValue());  // true
    

• 调用 instance.getSuperValue()会经历三个搜索步骤:1)搜索实例;2)搜索 SubType.prototype; 3)搜索 SuperType.prototype，最后一步才会找到该方法。在找不到属性或方法的情况下，搜索过 程总是要一环一环地前行到原型链末端才会停下来。
• 实际上，不是 SubType 的原型的 constructor 属性被重写了，而是 SubType 的原型指向了另一个对象—— SuperType 的原型，而这个原型对象的 constructor 属性指向的是 SuperType。
• 谨慎地定义方法:子类型有时候需要重写超类型中的某个方法，或者需要添加超类型中不存在的某个方法。但不管怎 样，给原型添加方法的代码一定要放在替换原型的语句之后。来看下面的例子

在上面的代码中，我们没有使用 SubType 默认提供的原型，而是给它换了一个新原型;这个新原型就是 SuperType的实例。于是，新原型不仅具有作为一个 SuperType 的实例所拥有的全部属性和方法， 而且其内部还有一个指针，指向了 SuperType 的原型。最终结果就是这样的:instance 指向 SubType 12 的原型，SubType 的原型又指向 SuperType 的原型。getSuperValue()方法仍然还在 SuperType.prototype 中，但 property 则位于 SubType.prototype 中。这是因为 property 是一 个实例属性，而 getSuperValue()则是一个原型方法。既然 SubType.prototype 现在是 SuperType的实例，那么 property 当然就位于该实例中了。此外，要注意 instance.constructor 现在指向的 是 SuperType，这是因为原来 SubType.prototype 中的 constructor 被重写了的缘故

• 注意点

function SuperType(){
    this.property = true;
}
SuperType.prototype.getSuperValue = function(){
    return this.property;
};
function SubType(){
    this.subproperty = false;
}
//继承了 SuperType
SubType.prototype = new SuperType();
//使用字面量添加新方法，会导致上一行代码无效 SubType.prototype = {
    getSubValue : function (){
        return this.subproperty;
},
    someOtherMethod : function (){
        return false;
} };
var instance = new SubType();
alert(instance.getSuperValue());   //error!

以上代码展示了刚刚把 SuperType 的实例赋值给原型，紧接着又将原型替换成一个对象字面量而 导致的问题。由于现在的原型包含的是一个 Object 的实例，而非 SuperType 的实例，因此我们设想 中的原型链已经被切断——SubType 和 SuperType 之间已经没有关系了

借用构造函数

在解决原型中包含引用类型值所带来问题的过程中，开发人员开始使用一种叫做借用构造函数 (constructor stealing)的技术(有时候也叫做伪造对象或经典继承)。这种技术的基本思想相当简单，即
在子类型构造函数的内部调用超类型构造函数。别忘了，函数只不过是在特定环境中执行代码的对象， 因此通过使用 apply()和 call()方法也可以在(将来)新创建的对象上执行构造函数

function SuperType(){
    this.colors = ["red", "blue", "green"];
 function SubType(){
//继承了 SuperType
    SuperType.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.传递参数
  相对于原型链而言，借用构造函数有一个很大的优势，即可以在子类型构造函数中向超类型构造函 数传递参数。

function SuperType(name){
    this.name = name;
}
function SubType(){
//继承了 SuperType，同时还传递了参数 SuperType.call(this, "Nicholas");
//实例属性
    this.age = 29;
}
var instance = new SubType();
alert(instance.name);    //"Nicholas";
alert(instance.age);     //29

• 2.借用构造函数的问题
  如果仅仅是借用构造函数，那么也将无法避免构造函数模式存在的问题——方法都在构造函数中定 义，因此函数复用就无从谈起了。而且，在超类型的原型中定义的方法，对子类型而言也是不可见的，结 果所有类型都只能使用构造函数模式。考虑到这些问题，借用构造函数的技术也是很少单独使用的。

组合继承

组合继承(combination inheritance)，有时候也叫做伪经典继承，指的是将原型链和借用构造函数的 技术组合到一块，从而发挥二者之长的一种继承模式。其背后的思路是使用原型链实现对原型属性和方 法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数 复用，又能够保证每个实例都有它自己的属性

    function SuperType(name) {
        this.name = name;
        this.color = ['red','blue','green'];
    }
    // 在原型上定义方法
    SuperType.prototype.sayName = function () {
        console.log(this.name)
    }
    function SubType(name,age) {
        // 继承subperType属性
        SuperType.call(this,name);
        this.age = age;
    }

    // 继承方法
    SubType.prototype = new SuperType();
    SubType.prototype.constructor = SubType;
    SubType.prototype.sayAge = function () {
        console.log(this.age);
    };

    var instance1 = new SubType('zhangcong',29);
    instance1.color.push('black');
    instance1.sayName();
    instance1.sayAge();
    console.log(instance1.color);

    var instance2 = new SubType('james',27);
    console.log(instance2.color);
    instance2.sayName();
    instance2.sayAge();

组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点，成为 JavaScript 中最常用的继 承模式。而且，instanceof 和 isPrototypeOf()也能够用于识别基于组合继承创建的对象。

原型式继承 (道格拉斯)

借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。为 了达到这个目的，他给出了如下函数。

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

在 object()函数内部，先创建了一个临时性的构造函数，然后将传入的对象作为这个构造函数的 原型，最后返回了这个临时类型的一个新实例。从本质上讲，object()对传入其中的对象执行了一次浅复制.

寄生式继承

寄生式(parasitic)继承是与原型式继承紧密相关的一种思路，并且同样也是由克罗克福德推而广 之的。寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该 函数在内部以某种方式来增强对象，最后再像真地是它做了所有工作一样返回对象。以下代码示范了寄 生式继承模式

function createAnother(original){
varclone=object(original); //通过调用函数创建一个新对象
 }
clone.sayHi = function(){ //以某种方式来增强这个对象
    alert("hi");
};
return clone; //返回这个对象

• 使用寄生式继承来为对象添加函数，会由于不能做到函数复用而降低效率;这一 点与构造函数模式类似。

寄生组合式继承

组合继承是 JavaScript 最常用的继承模式;不过，它也有自己的不足。组合继承最大的 问题就是无论什么情况下，都会调用两次超类型构造函数:一次是在创建子类型原型的时候，另一次是 在子类型构造函数内部。没错，子类型最终会包含超类型对象的全部实例属性，但我们不得不在调用子 类型构造函数时重写这些属性

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); //第二次调用SuperType()
    this.age = age;
}
SubType.prototype = new SuperType(); //第一次调用SuperType()
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
    alert(this.age);
};

• 在第一次调用 SuperType 构造函数时， SubType.prototype 会得到两个属性:name 和 colors;它们都是 SuperType 的实例属性，只不过 现在位于 SubType 的原型中。当调用 SubType 构造函数时，又会调用一次 SuperType 构造函数，这 一次又在新对象上创建了实例属性 name 和 colors。于是，这两个属性就屏蔽了原型中的两个同名属性.

• 所谓寄生组合式继承，即通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。其背 后的基本思路是:不必为了指定子类型的原型而调用超类型的构造函数，我们所需要的无非就是超类型 原型的一个副本而已。本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型 的原型.

    function inheritPrototype(subType,SuperType) {
        var prototype = Object(SuperType.prototype);   // 创建对象
        prototype.constructor = subType;					 // 增强对象
        subType.prototype = prototype;  					//指定对象
    }

    function SuperType(name) {
        this.name = name;
        this.color = ['red','black'];
    }
    SuperType.prototype.sayName = function () {
        alert(this.name);
    }
    function SubType(name,age) {
        SuperType.call(this,name);
        this.age = age;
    }
    inheritPrototype(SubType,SuperType);

    SubType.prototype.sayAge = function () {
        alert(this.age);
    }
    
    var instance = new SubType('zhangcogn',18);
    instance.sayName();
    instance.sayAge();
    
/**
* 另外一种写法
*     function inheritPrototype(subType,SuperType) {
*		function Temp(){}  // 创建一个空构造函数
*      Temp.prototype = SuperType.prototype;   // Temp的原型== SuperType的原型
*      var t = new Temp(); 					// 实例化一个构造函数
*      subType.prototype = t;				// subType的prototype == 实例构造函数
*      t.construction = subType;     // 增强对象
*    }
**/

总结

1.先明确谁继承谁? 在子类继承构造函数中通过call来借用父类构造函数.
2.构造一个寄生式方法. (创建对象 --> 增强对象—>指定对象);

核心代码

SuperType.call(this,name);

function inheritPrototype(subType,SuperType) {
var prototype = Object(SuperType.prototype); // 创建对象
prototype.constructor = subType; // 增强对象
subType.prototype = prototype; //指定对象
}

• 原型式继承，可以在不必预先定义构造函数的情况下实现继承，其本质是执行对给定对象的浅
  复制。而复制得到的副本还可以得到进一步改造。
• 寄生式继承，与原型式继承非常相似，也是基于某个对象或某些信息创建一个对象，然后增强
  对象，最后返回对象。为了解决组合继承模式由于多次调用超类型构造函数而导致的低效率问
  题，可以将这个模式与组合继承一起使用。
• 寄生组合式继承，集寄生式继承和组合继承的优点与一身，是实现基于类型继承的最有效方式。