javaScript实现继承的几种方式

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）

sub1.gif

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) 

image.png

说明：
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.寄生组合继承应该可以说是相对比较完美的继承的方式了！但是因为用起来比较麻烦，所以所以组合继承是依然是最常用的；