__proto__ 是指向的创建者的原型对象

constructor 是指向的创建者
prototype 是当前对象的原型对象

原型链继承

function Super(){
    this.val = 1;
    this.arr = [1];
}
function Sub(){
    // ...
}
Sub.prototype = new Super();    // 核心

// 拿父类实例来充当子类原型对象
// 缺点： 1. 修改sub1.arr后sub2.arr也变了，因为来自原型对象的引用属性是所有实例共享的
//       2. 创建子类实例时，无法向父类构造函数传参

原型式继承

function beget(obj){   
    var F = function(){};
    F.prototype = obj;
    return new F();
}
function Super(){
    this.val = 1;
    this.arr = [1];
}
var sup = new Super();
var sub = beget(sup);   // 核心

// 用生孩子函数得到得到一个“纯洁”的新对象（“纯洁”是因为没有实例属性），再逐步增强之（填充实例属性）
// 缺点： 原型引用属性会被所有实例共享，因为是用整个父类对象来充当了子类原型对象，所以这个缺陷无可避免
// 无法实现代码复用（新对象是现取的，属性是现添的，都没用函数封装，怎么复用）

构造函数继承

function Super(val){
    this.val = val;
    this.arr = [1];

    this.fun = function(){
        // ...
    }
}
function Sub(val){
    Super.call(this, val);   // 核心
    // ...
}
// 借父类的构造函数来增强子类实例，等于是把父类的实例属性复制了一份给子类实例装上了（完全没有用到原型）
// 缺点： 无法实现函数复用，每个子类实例都持有一个新的fun函数，太多了就会影响性能，内存爆炸。

组合继承

function Super(){
    // 只在此处声明基本属性和引用属性
    this.val = 1;
    this.arr = [1];
}
//  在此处声明函数
Super.prototype.fun1 = function(){};
Super.prototype.fun2 = function(){};
//Super.prototype.fun3...
function Sub(){
    Super.call(this);   // 核心
    // ...
}
Sub.prototype = new Super();    // 核心
// 把实例函数都放在原型对象上，以实现函数复用。同时还要保留借用构造函数方式的优点
// 缺点：（一点小瑕疵）子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，
//  而子类实例上的那一份屏蔽了子类原型上的。。。又是内存浪费

寄生式继承

function beget(obj){   // 生孩子函数 beget：龙beget龙，凤beget凤。
    var F = function(){};
    F.prototype = obj;
    return new F();
}
function Super(){
    this.val = 1;
    this.arr = [1];
}
function getSubObject(obj){
    // 创建新对象
    var clone = beget(obj); // 核心
    // 增强
    clone.attr1 = 1;
    clone.attr2 = 2;
    //clone.attr3...

    return clone;
}

var sub = getSubObject(new Super());
// 给原型式继承穿了个马甲而已，看起来更像继承了（上面介绍的原型式继承更像是对象复制）
// 缺点：无法实现函数复用（没用到原型，当然不行）

寄生组合继承（推荐）

function beget(obj){   // 生孩子函数 beget：龙beget龙，凤beget凤。
    var F = function(){};
    F.prototype = obj;
    return new F();
}
function Super(){
    // 只在此处声明基本属性和引用属性
    this.val = 1;
    this.arr = [1];
}
//  在此处声明函数
Super.prototype.fun1 = function(){};
Super.prototype.fun2 = function(){};
function Sub(){
    Super.call(this);   // 核心
    // ...
}
var proto = beget(Super.prototype); // 核心
proto.constructor = Sub;            // 核心
Sub.prototype = proto;              // 核心

var sub = new Sub();
// 通过组合的方式来继承父类的属性
// 通过寄生的方式来继承父类的原型对象