实现继承的几种方式
要搞懂JS继承，我们首先要理解原型链：每一个实例对象都有一个__proto__属性（隐式原型），在js内部用来查找原型链；每一个构造函数都有prototype属性（显式原型），用来显示修改对象的原型，实例.__proto__=构造函数.prototype=原型。原型链的特点就是：通过实例.__proto__查找原型上的属性，从子类一直向上查找对象原型的属性，继而形成一个查找链即原型链。
（1）原型链继承：
我们使用原型继承时，主要利用sub.prototype=new super，这样连通了子类-子类原型-父类。
核心：将父类的实例作为子类的原型。
//父类，带属性
function Super(){
this.flag = true;
}
//为了提高复用性，方法绑定在父类原型属性上
Super.prototype.getFlag = function(){
return this.flag;
}
//来个子类
function Sub(){
this.subFlag = false;
}
//实现继承
Sub.prototype = new Super();
//给子类添加子类特有的方法，注意顺序要在继承之后
Sub.prototype.getSubFlag = function(){
return this.subFlag;
}
//构造实例
var es5 = new Sub;
特点：
1. 非常纯粹的继承关系，实例是子类的实例，也是父类的实例
2. 父类新增原型方法/原型属性，子类都能访问到
-
为啥不用A.prototype = B.prototype的方式呢
因为如果更改A.prototype的话，会更改B.protptype 就是污染了B.prototype，就不能称之为继承。
而通过A.prototype = new B();如果更改A.prototype的话,不更改B.prototype，安全有效
缺点：
来自原型对象的引用属性是所有实例共享的，即属性没有私有化，原型对象上属性的改变（即 new Super出来的对象）会作用到所有的实例上。
（2）构造函数继承
在构造子类构造函数时内部使用call或apply来调用父类的构造函数
核心：使用父类的的构造函数来增强子类实例，等于是复制父类的实例属性给子类（没用到原型）
function Super(){
this.flag = true;
}
function Sub(){
// 用call是因为直接调用的话 this指向window 这样无法通过this.属性名 访问到父类中的属性
Super.call(this) //如果父类可以需要接收参数，这里也可以直接传递
}
var obj = new Sub();
obj.flag = flase;
var obj_2 = new Sub();
console.log(obj_2.flag) //依然是true，不会相互影响
优缺点：实现了属性的私有化，但是子类无法访问父类原型上的属性。
特点：
1. 解决了1中，子类实例共享父类引用属性的问题
2. 创建子类实例时，可以向父类传递参数
3. 可以实现多继承（call多个父类对象）
缺点：
1. 实例并不是父类的实例，只是子类的实例
2. 只能继承父类的实例属性和方法，不能继承原型属性/方法
- 无法实现函数复用，每个子类都有父类实例函数的副本，影响性能
（3）组合继承：
利用构造函数和原型链的方法，可以比较完美的实现继承
function Super(){
this.flag = true;
}
Super.prototype.getFlag = function(){
return this.flag; // 继承方法
}
function Sub(){
this.subFlag = flase
Super.call(this) // 继承属性
}
Sub.prototype = new Super;
var obj = new Sub();
// Sub.prototype = new Super; 会导致Sub.prototype的constructor指向Super;
// 然而constructor的定义是要指向原型属性对应的构造函数的，Sub.prototype是Sub构造函数的原型，
// 所以应该添加一句纠正：Sub.prototype.constructor = Sub;
Sub.prototype.constructor = Sub; // 修复构造函数指向
Super.prototype.getSubFlag = function(){
return this.flag;
}
特点：
1. 弥补了方式2的缺陷，可以继承实例属性/方法，也可以继承原型属性/方法
2. 既是子类的实例，也是父类的实例
3. 不存在引用属性共享问题
4. 可传参
5. 函数可复用
缺点：
1. 调用了两次父类构造函数，生成了两份实例（子类实例将子类原型上的那份屏蔽了）
（4）寄生组合继承：
核心：通过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点
function Fu(name) {
this.name = name;
this.arr = ['1'];
this.sayName = function() {
console.log(this.name);
}
}
Fu.prototype.sayHi = function() {
console.log('Hi, ' + this.name);
}
function Zi(name) {
Fu.apply(this, arguments);
this.name = name;
}
// Object.create创建对象，第一个参数指定原型对象
//这样可以把父对象的原型继承下来 而不会继承父对象构造函数中的属性和方法
在父对象.call(this)的时候才把构造函数中的属性和方法拿到，这样不会造成二次赋值
Zi.prototype = Object.create(Fu.prototype);
Zi.prototype.constructor = Zi;
//Object.create(Fu.prototype) 相当于下面的函数，先初始化一个F构造函数，F的原型指向obj，返回F的构造函数
function create(obj) {
let F = function(){};
F.prototype = obj;
return new F();
}
特点：使用到了Object.create(Fu.prototype)实现原型链的浅拷贝
优点：解决了原型链继承和构造函数继承的缺点
缺点：
function Fu(name) {
this.name = name;
this.arr = ['1'];
this.sayName = function() {
console.log(this.name);
}
}
Fu.prototype.sayHi = function() {
console.log('Hi, ' + this.name);
}
function Zi(name) {
Fu.apply(this, arguments);
this.name = name;
}
// 在继承之前定义的方法 是会不见的
Zi.prototype.subSay = function() {
console.log('111');
}
Zi.prototype = Object.create(Fu.prototype);
Zi.prototype.constructor = Zi;
（5）圣杯模式继承
思想：
另外加个构造函数 function F（）{}当做中间层，然后让 F 和 father 共有一个原型 F.prototype=father.prototype，然后 son.prototype = new F（）；使用原型链形成了继承关系，现在改 son.prototype 就不会影响 father.prototype
function inherit (function(){
var F = function(){};
return function(Target,Origin){
F.prototype = Oigin.prototype;
target.prototype = new F();
Target.prototype.constuctor = Target; // 防止constuctor指向紊乱
Target.prototype.uber = Origin.prototype; //// 找到自己的超级父级，为了让我们知道Target到底继承自谁
}
})
Father.prototype.lastname = "Alex";
function Father(){
}
function Son(){
}
inherit(Son,Father);
var son = new Son();
var father new Fahter();
注意：
（1）利用了闭包的机制 ，形成闭包，让F 变成了私有化变量。毕竟F函数只是一个过渡层，没有其它的作用。生成闭包将其不暴露在外是最好的。
（2）圣杯模式继承和寄生组合继承都是较好的处理继承的方法。
参考文章
