1. 原型链继承（子类的原型等于父类的实例）

            <!-- 父类 -- >
            function Super(name) {
                this.name = name
            }
            Super.prototype = {
                name: '我要走走看看',
                age: 18,
                hobby: { a: '篮球' },
            }
             <!-- 子类 -- >
            function Sub() {}

            Sub.prototype = new Super() // 子类的原型等于父类的实例

            const sub = new Sub()
            console.log(sub.age) // 18

缺点：

1. 子类无法想父类的构造函数传参.??new Sub( name )父类也接收不到

2. 子类修改父类原型中引用类型的值时，原型的属性发生改变，导致之后的实例的值都发生改变

注：给变量赋值，是引用还是复制

            const sub1 = new Sub()
            const sub2 = new Sub()
            sub1.hobby.a = '羽毛球'  // 这里修改了sub1的hobby的值
            console.log(sub1.hobby) // { a: '羽毛球' }
            console.log(sub2.hobby) // { a: '羽毛球' }

2.借用构造函数继承?

通过 call 、apply将父类构造函数的方法引入子类

            // 父类
            function Super(name) {
                this.name = name
            }
            Super.prototype = {
                name: '我要走走看看',
                age: 18,
                hobby: { a: '篮球' },
            }
            // 子类
            function Sub(name) {
                Super.call(this,name)// 通过  call / apply 继承父类构造函数内的属性和方法
            }
            const sub = new Sub('猫咪')
            console.log(sub.name)  // 猫咪
            console.log(sub.age)   // undefined

优点：1. 解决了子类实例向父类传参的缺点?

? ? ? ? ? ? 2.解决了子类实例修改父类原型属性或者方法的问题

? ? ? ? ? ? 3.?可以继承多个构造函数属性（call多个）。

缺点： 1. 无法继承父类原型的方法和属性

? ? ? ? ? ? 2.?每个新实例都有父类构造函数的副本，无法复用，臃肿。

3. 组合继承（j原型链继承 + 构造函数继承）

            // 父类
            function Super(name) {
                this.name = name
            }
            Super.prototype = {
                name: '我要走走看看',
                age: 18,
                hobby: { a: '篮球' },
            }
            // 子类
            function Sub(name) {
                Super.call(this,name)   // 1: 调用第一次
            }
            Sub.prototype = new Super() // 2: 调用第二次

?优点：可传参 + 继承了父类的原型

?缺点：两次调用父类的构造函数（耗内存）

4. 原型式继承

            function Super(name) {
                this.name = name
            }
            Super.prototype.sayName = function() {
                console.log(this.name)
            }
            const a = new Super('姓名')

            <!---这里相当于Object.create()做的事，将 现有对象 作为 新对象的原型 --->
            function inherit(o) {
                function F() {}
                F.prototype = o
                return new F()
            }
            const b1 = inherit(a)
            <!-------->
            
            console.log(b.name) // 姓名

上述注释中的代码类似于

 const b1 = Object.create(a)

用Object.create更好一点，还可以加上额外的属性

          const b1 = Object.create(a, {
                age: {
                    value: 15,
                    writable: true,
                },
                address: {
                    value: '上海',
                    writable: true,
                },
            })

缺点：无法复用，原型都是手动添加上去的? ?

5 . 寄生组合式继承（常用）

            function Super(name) {
                this.name = name
                this.age = 21
            }
            Super.prototype = Object.assign({
                sayName: () => {
                    console.log(this.name)
                },
                address: '上海',
                hobby: ['唱歌'],
            })

            function Sub(name) {
                Super.call(this, name) // 继承父类构造函数的属性
            }
            Sub.prototype = Object.create(Super.prototype) // 继承父类的原型
            const sub1 = new Sub('姓名1')
            console.log(this.name) // 姓名1

优点：既可以传参又实现了原型的复用? ? ??