3分钟彻底理解，js继承的6种方式

2017-10-11 本文已影响60人熊师傅

前言：了解熊师傅的朋友都知道，百度能查的到东西绝对不会提及太多，但是如果能按照思路仔细揣摩相信你一定不会后悔的，接下来开始我的表演。

三分钟彻悟？哈哈哈。。。
原型链自不必说是js前期最晦涩难懂的地方，也是基础中的基础，是每一位前端必须有所了解的。

别怕，熊师傅带你来干 ^ . ^

一.原型链继承

        function aaa (name) {
            this.name = name;
        }
        aaa.prototype.getName = function () {
            return this.name;
        }
        function bbb (name) {
        }
        bbb.prototype = new aaa(‘我是哈哈’);

核心代码： bbb.prototype = new aaa()
将bbb的原型指向aaa的实例，aaa的属性和原型方法都将挂载到bbb的原型下面。
缺点：
1.bbb无法给aaa（父类）的构造函数传递参数 (无法继承构造函数)
2.如果bbb的构造函数也有name属性，依然会在原型上继承aaa的name属性，造成内存浪费

二.借用构造函数继承

        function aaa () {
            this.name = name;
        }
        aaa.prototype.getName = function () {
            return this.name;
        }
        
        function bbb (name, age) {
            aaa.apply(this, name);
            this.age = age;
        }
        
        var oBBB = new bbb();

核心代码： aaa.apply(this, name)
在new bbb() 的时候调用aaa，借用aaa的构造函数。
缺点：
1.无法做到函数复用（说白了，没有prototype）

三.组合继承

        function aaa () {
            this.name = name;
        }
        aaa.prototype.getName = function () {
            return this.name;
        }
        
        function bbb (name, age) {
            aaa.apply(this, name);
            this.age = age;
        }
        
        bbb.prototype = new aaa();
        
        var oBBB = new bbb();

什么是组合继承？
说白了，就是把前面两种继承方式结合起来
核心代码：
aaa.apply(this, name);
bbb.prototype = new aaa();
思路：bbb通过call借用aaa的构造函数，并将aaa的属性和原型方法挂载在自己的原型上面。
缺点：
1.依然会造成内存浪费，会把aaa的属性也写到bbb的原型上面去。

四.原型式继承

先好好揣摩下这个东西

function object (o) {
    function F () {}
    F.prototype = o;
    return new F();
}

那么这种模式怎么继承呢？

var aaa = {
    name: 'xxx',
    age: '18',
}

var aaa1 = object(aaa);
var aaa2 = object(aaa);

很显然aaa1和aaa2的原型上面都会有name和age属性。
当然缺点也很明显了：
1.构造函数和prototype不分，所有实例的原型引用一致，容易造成重写，和原型链继承的缺点一样

五.寄生式继承

说白了，对原型式继承做了一次改造。先看看如下东西：

function createAnother (obj) {
   var clone = object(obj);
    clone.sayHi = function() {
        alert('hi');
    }
    return clone;
}

var aaa = {
    name: '111',
    age: '2',
};

var aaa1 = createAnother(aaa);

缺点：
1.构造函数无法复用，也无法接受参数。（其实有改造空间，把createAnother通过闭包再封装一层，不过个人不推荐再改造）

六.寄生组合式继承

堪称最完美的方式：

// 这个命名牛逼不？  in her it ，老铁，意会 ^.^
function inherit (sub, sup) {
    var prototype = object(sup.prototype);
    prototype.constructor = sub;
    sub.prototype = prototype;
}

function aaa (name) {
    this.name = name;
}
aaa.prototype.getName = function () {
    alert('111');
}

function bbb (name, age) {
    aaa.call(this, name);
    this.age = age;
}
inherit(bbb, aaa);
bbb.prototype.xixi = function() {
    alert('xixi');
}

到这里基本上解决了所有的问题，perfect。具体的工作原理，前5种继承方式如果认真研究过一遍了，基本上无需再解释，若看不懂回过头来再温习一遍，熊师傅对于这一块也是来回研究了十来遍才咯知一二。

但是。
熊师傅对于第六种继承方式提出一些大家可能会有的疑惑。

1.不是一样子类继承父类之后，父类的prototype依然会共享，同一个引用依然会改变父类的原型呀？
2.inherit有什么意义？ 和  sub.prototype = sup.prototype有什么区别？为什么非要通过object方法？

说实话，作者在这里也琢磨了一段时间，算是有一些自己的见解。如有不对，欢迎指正

1.好好想一想我们为什么要继承？不就是为了复用吗？如果不是同一个引用，那继承又有什么意义？（是不是有点恍然大悟的意思^.^）
2.这里通过inherit会重新指正子类sub的构造函数，如果简单的 sub.prototype = sup.prototype, sub.prototype.constructor = sub 会影响父类sup.