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

推荐阅读更多精彩内容