1.原型链继承

1
2
3
4
5

        // 1. 原型链继承
        function A() { }
        function B() { }
        B.prototype = new A();
        let a = new B();

缺点：1.原型中包含的引用值会在实例间共享2.子类型在实例化时不能给父类型构造函数传参

2.盗用构造函数继承（经典继承）

1
2
3
4
5
6

        // 2. 经典继承
        function A(params) { }
        function B() {
            A.call(this, params)
        }
        let a = new B();

缺点：1.子类不能访问父类原型上定义的方法

3.组合继承

1
2
3
4
5
6
7

        // 3.组合继承
        function A(params) { }
        function B() {
            A.call(this, params)
        }
        B.prototype = new A();
        let a = new B()

缺点：1.存在效率问题，父类构造函数始终会被调用两次

4.原型式继承

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

        // 4.原型式继承
        let obj = {
            name: '星空海绵',
            getName: function () {
                return this.name
            }
        }
        function object(o) {
            function F() { }
            F.prototype = o;
            return new F();
        }
        let obj1 = object(obj);

Object.create的原理就是原型式继承

缺点：原型式继承和原型链继承缺点一样，原型中包含的引用值会在实例间共享。

优点：适合不需要单独创建构造函数，但是需要对象间共享信息的场景。

5.寄生式继承

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

        // 5.寄生式继承
        let obj = {
            name: '星空海绵'
        }
        function object(o) {
            function F() { }
            F.prototype = o;
            return new F();
        }
        function A(o) {
            let clone = object(o);
            clone.getName = function () {
                return this.name
            }
            return clone
        }
        let obj1 = A(obj);

缺点：寄生式继承给对象添加的函数会导致函数难以重用

6.寄生式组合继承

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

        // 6.寄生式组合继承
        function object(o) {
            function F() { }
            F.prototype = o;
            return new F();
        }
        function inheritPrototype(B, A) {
            let prototype = object(A.prototype);
            prototype.constructor = B;
            B.prototype = prototype;
        }
        function A(params) { }
        function B() {
            A.call(this, params)
        }
        inheritPrototype(B, A);

寄生式组合继承可以算是引用类型的最佳模式

7.类继承

1
2
3
4
5
6

        // 7.类继承
        function A() {
            this.name = '星空海绵'
        }
        class B extends A { }
        let a = new B()

ES6新增的语法，背后使用的依然是原型链。

完！