继承模式（原型式，原型链，构造函数，组合，寄生，寄生组合）

寄生组合式是最终方案，满足前面所有其他方案在继承时的不足（继承原型，子类创建自己实例，对子类可以进行加强）

1. 原型式
2. 原型链式
3. 构造函数
4. 组合式
5. 寄生式
6. 寄生组合式

talk is cheap show me your code!!!

原型式

//方案1
let parent = {
    name:'parent'
}
let child = Object.create(parent)
console.log(child.name)
//方案2
let parent = {
    name:'parent'
}
function child() {}
child.prototype = parent
let c = new child()
console.log(c.name)

原型链式

优势：可以继承原型上的方法属性

不足：实例共用原型上属性方法，子类实例修改引用类型值时，会影响原型和其他实例

function parent () {
    this.name = 'parent'
    this.age = '111'
    this.info = {
        info:123
    }
 }
 function child () {}
 child.prototype = new parent()
 let c = new child()
 let b = new child()
 child.prototype.info.info = '12123'
 b.info.info  = 'afdadsdf'
 console.log(c.info.info)

构造函数

优势：可以传参，每个实例有自己的属性和方法

不足：只相当于执行了父类，还没有继承原型上的属性方法

function parent () {
    this.info = {
        name:'parent'
    }
}
function child() {
    parent.call(this)
}
let b = new child()
b.info.namme = '12'
let c = new child()
console.log(c.info)

寄生

特点：对父类继承之后的子类做一个加强，不影响父类

let parent = {
    name:'parent'
}
let c = Object.create(parent)
c.getname = function() {console.log(this.name)}

寄生组合式

特点：最终方案，满足继承父类原型属性方法，子类有自己的实例属性方法，对子类可以进行加强

function parent() {
    this.info = {
        age:1
    }
}
parent.prototype.pfn = function() {console.log('pfn')}
let child = function() {
    parent.call(this)
}
let p = Object.create(new parent())
p.addFn = function() {console.log('addfn')}
child.prototype = p
p.constructor = child
let c = new child()
let b = new child()
b.info.age = 'hh'
p.info.age = 'hhh'
console.log(c.info.age)
c.addFn()
c.pfn()
// parent.addFn()