原型链及继承

什么是原型？

 function Person(){
     
 }
 let p = new Person()

实例对象拥有__proto__
函数拥有Person.prototype,Person.prototype就是原型，它是一个对象，我们也称它为原型对象。

什么是原型链

原型与原型层层相链接的过程即为原型链。

Object.prototype.__proto__ // null
Function.prototype.__proto__ === Object.prototype // true
Function.__proto__ === Function.prototype // true

 function Person(params) {
            
        }
        Person.prototype.n = 1
        Person.prototype.add = function () {
            this.n++
        }
        let p1 = new Person()
        let p2 = new Person()
        p1.add()
        p2.add()
        console.log(Person.prototype.n) // 1

p1.add()执行时，add中this的指向为p1这个对象实例，当p1的属性找不到n时，通过原型链向上查找，找到n=1,然后给当前对象p1进行赋值

原型继承

原型模式

        function Person() {
            this.name = '小王'
            this.color = ['red', 'black']
            this.getName = function () {
                console.log(this.name);
            }
        }


        function Man() {
            this.name = '小黄'
        }

        Man.prototype = new Person()
      
        const man = new Man()
        const man2 = new Man()

        man.color.push('green')

        console.log(man.color); // ['red', 'black', 'green']
        console.log(man2.color); // ['red', 'black', 'green']

两个问题：

• 原型中的引用值会在多个实例间共享
• 子类型在实例化时不能给夫类型的构造函数传参

盗用构造函数（对象伪装 或 经典继承）

        function Person() {
            this.name = '小王'
            this.color = ['red', 'black']
            this.getName = function () {
                console.log(this.name);
            }
        }


        function Man() {
            Person.call(this)
            this.name = '小黄'
        }

      
        const man = new Man()
        const man2 = new Man()

        man.color.push('green')
        
        console.log(man.color); // ['red', 'black', 'green']
        console.log(man2.color); // ['red', 'black']

通过使用call()（或apply()）方法，Person的构造函数在Man的实例创建的上下文中执行了。相当于新的Man对象上运行了Person函数中的所有初始化代码,结果就是每个实例都会有自己的colors属性。

优点

• 能够在子类构造函数中像父类构造函数传参

问题

• 必须在构造函数中定义方法，因此函数不能重用
• 子类也不能访问父类原型上定义的方法，因此所有类型只能使用构造函数模式

组合继承（伪经典继承）

综合原型链和盗用构造函数，结合两者的优点。

思路是使用原型链继承原型上的属性和方法，通过盗用构造函数继承实例属性

        function Person() {
            this.name = '小王'
            this.color = ['red', 'black']
            this.getName = function () {
                console.log(this.name);
            }
        }


        function Man() {
            // 继承构造函数实例的属性
            Person.call(this)
            this.name = '小黄'
        }

        // 继承原型的属性和方法
        Man.prototype = new Person()
        
        const man = new Man()
        const man2 = new Man()

        man.color.push('green')
        
        console.log(man.color); // ['red', 'black', 'green']
        console.log(man2.color); // ['red', 'black']

组合继承弥补了原型链和盗用构造函数的不足，是JavaScript中使用最多的继承模式。而且组合继承也保留了instanceof操作符和isPrototypeOf()方法识别合成对象的能力。

原型式继承

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

object会创建一个临时构造函数，将传入的对象赋值给这个构造函数的原型，然后返回这个临时构造函数的实例。

实质上是对传入对象的一次浅复制，所以还存在值引用的问题。

        let obj = {
            age: 23,
            height: 180,
            skill: ['java', 'js']
        }
        const man = object(obj)
        const man1 = object(obj)
        // es5新增了Object.ceate的方法可替代
        const man = Object.create(obj)
        const man1 = Object.create(obj)
        
        man.skill.push('c++')
        man.skill; // ["java", "js", "c++"]
        man1.skill;// ["java", "js", "c++"]

原型式继承非常适合不需要单独创建构造函数，但仍然需要在对象间共享信息的场合。但要记住，属性中包含的引用值始终会在相关对象间共享，跟使用原型模式是一样的。

寄生式继承

寄生式继承背后的思路类似于寄生构造函数和工厂模式：创建一个实现继承的函数，以某种方式增强对象，然后返回这个对象。

        function createAnother(original) {
            // 通过调用函数创建一个新的对象
            let clone = object(original);
            // 以某种方式增强这个对象
            clone.sayHi = function () {
                console.log('Hi');
            }
            // 返回这个对象
            return clone
        }

        let person = {
            name: 'tom',
            friends: ['jerry', 'arthur']
        }
        let anoherPerson = createAnother(person);
        anoherPerson.sayHi()

寄生式继承同样适合主要关注对象，而不在乎类型和构造函数的场景。object()函数不是寄生式继承所必需的，任何返回新对象的函数都可以在这里使用。

寄生式组合继承

组合继承其实也存在效率问题。最主要的效率问题就是父类构造函数始终会被调用两次：一次在是创建子类原型时调用，另一次是在子类构造函数中调用。

寄生式组合继承通过盗用构造函数继承属性，但使用混合式原型链继承方法。基本思路是不通过调用父类构造函数给子类原型赋值，而是取得父类原型的一个副本。说到底就是使用寄生式继承来继承父类原型，然后将返回的新对象赋值给子类原型。

  function Person() {
            this.name = '小王'
            this.color = ['red', 'black']
            this.getName = function () {
                console.log(this.name);
            }
        }

        Person.prototype.code = function () {
            console.log('coding');
        }

        Person.prototype.skill = ['java', 'js']

        function Man() {
            Person.call(this)
        }


        function inheritPrototype(man, person) {
            const prototype = person.prototype
            prototype.constructor = man;
            man.prototype = prototype
        }

        inheritPrototype(Man, Person)
        const man = new Man()

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