继承的六种实现方式

1：原型链继承

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

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;
var instance = new SubType();
alert(instance.getSuperValue());//true

缺点：最主要的问题来自包含引 用类型值的原型。想必大家还记得，我们前面介绍过包含引用类型值的原型属性会被所有实例共享

2：借用构造函数

基本思想相当简单，即 在子类型构造函数的内部调用超类型构造函数

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"

优点：子类型构造函数中向超类型构造函 数传递参数
缺点：也将无法避免构造函数模式存在的问题——方法都在构造函数中定 义，因此函数复用就无从谈起了

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);
instance1.sayName();
instance1.sayAge();
//"red,blue,green,black"
//"Nicholas";
//29
 var instance2 = new SubType("Greg", 27);
alert(instance2.colors);
instance2.sayName();
instance2.sayAge();
//"red,blue,green"
//"Greg";
//27

组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点
组合继承最大的 问题就是无论什么情况下，都会调用两次超类型构造函数

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); //这句话也可以替换为 Object.create(person)
    yetAnotherPerson.name = "Linda";
    yetAnotherPerson.friends.push("Barbie");
    alert(person.friends);   //"Shelby,Court,Van,Rob,Barbie"

缺点：包含引用类型值的属性始终都会共享相应的值，就像使用 原型模式 一样。

5：寄生式继承

寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该 函数在内部以某种方式来增强对象，最后再像真地是它做了所有工作一样返回对象。

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

var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi(); //"hi"

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

6：寄生组合式继承

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

function inheritPrototype(subType, superType){
    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(SubType, SuperType);//关键
SubType.prototype.sayAge = function(){
    alert(this.age);
}

这个例子的高效率体现在它只调用了一次 SuperType 构造函数，并且因此避免了在 SubType. prototype 上面创建不必要的、多余的属性。与此同时，原型链还能保持不变;因此，还能够正常使用 instanceof 和 isPrototypeOf()。开发人员普遍认为寄生组合式继承是引用类型最理想的继承范式。