借用构造函数
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 本身就是一个用来过度的东西， 除此之外并无实际意义。这是闭包的一种功能： 私有化变量。
