JavaScript中的继承

JavaScript中的继承是通过原型链实现的，有几种设计继承的方法总结如下：

一. 原型链

  基本思想：每个构造函数都有一个原型对象，原型对象又都包含一个指向构造函数的指针，而实例又指向一个原型对象的指针，那么，如果我们让原型对象等于另一个类型的实例，此时的原型对象将包含一个指向另一个原型的指针，相应的另一个原型中也包含着一个指向另一个构造函数的指针，假如另一个原型又是另一个类型的实例呢，那么上述的关系依然成立，如此层层递进，就构成了实例和原型的链条。下面是例子

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(instace.getSuperValue());//true

缺点：引用类型值的属性会被所有实例共享，假设有两个子类型的实例，其中一个实例修改了从超类型继承而来的引用类型的值，修改的结果也同样会在另一个实例中显示出来；

        创建子类型的实例的时候，不能向超类型的构造函数中传递参数。

二.借用构造函数

     基本思想：在子类型构造函数的内部调用超类型构造函数，即通过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"

优点：解决了原型中包含引用类型值所带来的问题

缺点：超类型的原型中定义的方法，对子类型而言也是不可见的（没有指向超类型原型的指针，只有指向构造函数的），结果所有类型都只能使用构造函数模式，这样肯定是不好的。

三.组合继承

基本思想：使用原型链实现对原型属性和方法的继承，通过借用构造函数来实现对实例属性的继承下面是例子

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

组合继承是最常用的继承模式，而且，利用instanceof 和isprototypeof()也能够用于识别基于组合继承创建的对象

四.原型式继承

基本思想：借助原型可以基于已有的对象创建新对象，同时，不必因此创建自定义类型。下面是例子

function object(o){
  function F(){};
  F.prototype = o;
  return new F();
}
var person = {
  name:"Nicholas",
  friends:["shelby","Cour","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"

缺点：还是包含引用类型值得属性始终会共享相应的值，实例中修改会在原型中展现。

        无论什么情况下都会调用两次超类型构造函数：一次是在创建子类型原型的时候，另一次是在子类型构造函数内部，子类型最后会包含超类型中的全部实例属性，但有时候我们会在调用子类型构造函数时重写这些属性。

五.寄生式继承

基本思路：与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式类增强对象。下面是例子：

 function object(o){
    function F(){};
    F.prototype = o;
    return new F();
 }
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"

使用场景：在主要考虑对象而不是自定义类型和构造函数的情况下。

六.寄生组合式继承

     为了解决组合继承的缺点

     基本思想：通过借用构造函数来继承属性，通过原型链的混成形式来继承方法

function object(o){
    function F(){};
    F.prototype = o;
    return new F();
 }
function inheritPrototype(subType,superType){
  var prototype = object(superType.ptorotype);//创建对象
  prototype.constructor = subType;//增强对象
  subType.prototype = prototype;//指定对象
}

  能够正常使用instanceof() 和 isPrototypeOf()。