JavaScript之继承的发展史

1.传统形式–原型链
缺点：过多的继承了很多没有用的属性

Grand.prototype.lastname = "ji";
  function Gand(){

  }
  var grand = new Grand();

  Father.prototype = grand;
  function Father(){
    this.name = "hehe";
  }
  var father = new Father();

  Son.prototype = father;
  function Son(){

  }
  var son = new Son();

2.借用构造函数
缺点：不能继承借用构造函数的原型
每次构造函数都要多走一个函数

 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 student = new Student();

3.共享原型
缺点：不能随便改动自己的原型

Father.prototype.lastName = "Deng";
function Father(){
}
function Son(){
}
// Son.prototype = Father.prototype;
// var son = new Son();
// var father = new Father(){};
// 共享原型函数
function inherit(Target,Origin){
  Target.prototype = Origin.prototype;
}
iniherit(Son,Father);
var son = new Son();

我们发现在控制台给Son.prototype多加一个sex，Father.prototype也会多增加一个sex。

4.圣杯模式

function inherit(Target,Origin){
  function F(){}
  F.prototype = Origin.prototype;
  Target.prototype = new F();  //和上面的语句不能互换，会改变原型的指向，必须要在new之前改变原型的指向
  //原型上都有一个默认的属性constuctor，指向他的构造函数，因此在这里son.constuctor
  // 理应指向Son，但是现在他指向Father
  // son._proto_  -->new F()._proto_ -->Father.prototype
  Target.prototype.constuctor = Target;  //son的constuctor归位
  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.constuctor = Target;
//     Target.prototype.uber = Origin.prototype;
//   }
// }());

Father.prototype.lastname = "Deng";
function Father(){
}
function Son(){
}
inherit(Son,Father);
var son = new Son();
var father = new Father();