借用构造函数

function Person(name, age, sex){
   this.name = name;
   this.age = age;
   this.sex = sex;
}

function Student(name, age, sex, grade){
   Person.call(this, name, age, sex);
   this.grade = grade;  
} 

var stu = new Student("hehe", 12, 'male', 6)

在 student 构造函数中调用了 Person， 然后将 student 与 Person 的共同属性使用Person.call实现。

• 不能继承构造函数的原型， 所以这不是严格意义上的继承。 student的原型还是 student.prototype
• 每次构造都要多执行一个函数。

共享原型

Father.prototype.lastName = "Yang"
function Father(){
}
function Son (){
}
Son.prototype = Father.prototype

让 Son 的原型 等于 Father 的原型。
那么 Son.lastName == Father.lastName， 很自然， 父子同姓。

function inherit (target, origin){
  target.prototype = origin.prototype
}
inherit(Son, Father)

将两个构造函数传递进去， 改变子类原型的指向。但是这个操作一定要在生产实例对象之前执行， 否则实例化之后， 原型才改变， 那之前生产的实例就没有继承父类的原型。

这个方式依旧不完美。

• 子类的原型指向父类的原型， 如果子类想在原型上添加一个方法， 去执行一些私有的事情， 那么这个方法添加之后， 父类的原型上也会得到体现。
• 同样的道理， 父类在自己的原型上添加了一个方法， 或者属性， 比如娶了个老婆。然后儿子能调用。。。

圣杯模式继承

原理是基于上面的共享原型， 但是为了避开上面的负面影响。需要有一个层来将父子原型隔开， 但是子类依然能继承该继承的父类属性以及方法。

function inherit(target, origin){
  function F(){};
  F.prototype = origin.prototype;
  target.prototype = new F();
}

这样就阻断了父子类之间原型的直接关系。但是这个时候继承出来 target 实例的 constructor 指向的是 origin。所以还需要将 target 实例的 constructor 指向 target 他自己。

另外，某个时候， 子类可能想知道自己究竟继承自哪一个类。所以最好在子类身上给一个标记。

function inherit(Target, Origin){
  function F(){};
  F.prototype = Origin.prototype;
  Target.prototype = new F();
  Target.prototype.constructor = Target;
  Target.prototype.uber = Origin.prototype;
}

这是最好的继承方式。

var inherit = (function(){
  var F = function(){};
  return function(Target, Origin){
    F.prototype = Origin.prototype;
    Target.prototype = new F();
    Target.prototype.constructor = Target;
    Target.prototype.uber = Origin.prototype;
  }
})()

在这种写法中， F 存在于闭包之中， 通过 inherit.F 的方式访问不到。 因为 F 本身就是一个用来过度的东西， 除此之外并无实际意义。这是闭包的一种功能： 私有化变量。