1.原型链继承（最简单的继承）
function Parent () {
this.name = '小梁'
this.arr = [1]
}
function Sub() {}
Sub.prototype = new Parent()
var sub1 = new Sub()
var sub2 = new Sub()
sub1.name = '碳碳'
sub1.arr.push(22)
console.log(sub1.name) //碳碳
console.log(sub2.name) //小梁
console.log(sub1.arr) //[1,22]
console.log(sub2.arr) //[1,22]
说明：
1.原型链继承其实可以用一句话总结：拿父类实例来充当子类原型对象；
2.上面这个例子可以这样子理解：
*sub1.name = '碳碳'：给sub1定义了一个name属性值为‘碳碳’（在实例属性中寻找name,找到了就改变该实例属性的值，找不到就新建该属性并进行赋值）；
*sub1.arr.push(22)：为实例sub1的arr数组添加一个元素，先在sub1的实例属性中寻找名为arr的数组，没有找到，沿着原型链往上找，找到了arr数组，并对该数组进行操作；因为来自原型对象的引用属性是所有实例共享的所以sub2.arr的值也跟着改变了；
*console.log(sub1.name)：先在实例属性中寻找name属性，之前/sub1.name = '碳碳'/操作为sub1实例创建了name属性，所以在实例属性中能够找到name属性，值为‘碳碳’；
*console.log(sub2.name)：先在实例属性中寻找name属性，找不到；沿着原型链往上找，找到了值为‘小梁’的name属性。
3.优点：简单
4.缺点：
4.1修改sub1.arr后sub2.arr也变了，因为来自原型对象的引用属性是所有实例共享的。
4.2创建子类实例时，无法向父类构造函数传参
2.借用构造函数继承
function Parent (value) {
this.value = value
this.arr = ['one']
this.fun = function () {
console.log('smile')
}
}
function Sub(value) {
Parent.call(this,value)
}
var sub1 = new Sub(1)
var sub2 = new Sub(2)
sub1.value = 4
sub1.arr.push('two')
console.log(sub1.value) //4
console.log(sub2.value) //2
console.log(sub1.arr) //["one", "two"]
console.log(sub2.arr) //["one"]
console.log(sub1.fun == sub2.fun) //false
说明：
1.借父类的构造函数来增强子类实例，等于是把父类的实例属性复制了一份给子类实例装上了
2.优点：
2.1解决了子类实例共享父类引用属性的问题;
2.2创建子类实例时，可以向父类构造函数传参;
3.缺点：无法实现函数复用，每个子类实例都持有一个新的fun函数，太多了就会影响性能。
3.组合继承(原型+构造函数)
function Parent (value) {
this.value = value
this.arr = ['one']
}
Parent.prototype.fun = function () {
return 'smile'
}
function Sub(value){
Parent.call(this,value)
}
Sub.prototype = new Parent()
var sub1 = new Sub(1)
var sub2 = new Sub(2)
console.log(sub1.value) //1
console.log(sub2.value) //2
console.log(sub1.fun == sub2.fun) //true
说明：
1.把实例函数都放在原型对象上，以实现函数复用。同时还要保留借用构造函数方式的优点，通过Parent.call(this,value)继承父类的基本属性和引用属性并保留能传参的优点；通过Sub.prototype = new Parent()继承父类函数，实现函数复用；
2.优点：
不存在引用属性共享问题；
可传参；
函数可复用；
3.缺点
子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，而子类实例上的那一份屏蔽了子类原型上的。。。又造成了内存浪费：
例如：console.log(sub1）
4.原型继承
function sheng(obj) { //生孩子函数
var F = function() {}
F.prototype = obj
return new F
}
function parent() {
this.value = 1;
this.arr = ['aaa']
}
var sub = sheng(new parent())
//增强
sub.name = 'xiaoliang'
console.log(sub.value) //1
console.log(sub.arr) //['aaa']
console.log(sub.name) //'xiaoliang'
console.log(sub)
说明：
1.用生孩子函数得到得到一个“纯洁”的新对象（“纯洁”是因为没有实例属性），再逐步增强之（填充实例属性）
2.优点：从已有对象衍生新对象，不需要创建自定义类型；
3.缺点：
3.1原型引用属性会被所有实例共享，因为是用整个父类对象来充当了子类原型对象，所以这个缺陷无可避免
3.2无法实现代码复用
5.寄生式继承
function sheng(obj) {
var F = function() {}
F.prototype = obj
return new F()
}
function parent() {
this.value = 1;
this.arr = ['aaa']
}
function creatSub(obj) {
var clone = sheng(obj)
//增强
clone.name = '小梁'
return clone
}
var sub = creatSub(new parent())
console.log(sub.name)
说明：
1.其实觉得寄生式和原型式差别不大，就是新增一个函数来进行实例增强而已=。=。。
6.寄生组合继承（最佳方式）
function Super(obj){
var F = function(){};
F.prototype = obj;
return new F();
}
function Parent(){
this.val = 1;
this.arr = [1];
}
Parent.prototype.fun1 = function(){};
Parent.prototype.fun2 = function(){};
function Sub(){
Parent.call(this); // 核心
}
var proto = Super(Parent.prototype); // 核心
proto.constructor = Sub; // 核心
Sub.prototype = proto; // 核心
var sub = new Sub();
console.log(sub.val)
console.log(sub.arr)
说明：
1.寄生组合继承应该可以说是相对比较完美的继承的方式了！但是因为用起来比较麻烦，所以所以组合继承是依然是最常用的；
