Паразитическое композиционное наследование JavaScript

внешний интерфейс JavaScript
Паразитическое композиционное наследование JavaScript

Это седьмой день моего участия в августовском испытании обновлений, подробности о мероприятии:Испытание августовского обновления

наследование композиции

Комбинаторное наследование, также известное как псевдоклассическое наследование, сочетает в себе цепочку прототипов и конструкторы кражи, о которых мы говорили вчера, объединяя преимущества обоих. Его основная идея состоит в том, чтобы использовать цепочку прототипов для наследования свойств и методов прототипа и наследования свойств экземпляра путем кражи конструктора.Преимущество этого заключается в том, что определение метода можно повторно использовать в прототипе, и каждый экземпляр имеет свой собственные свойства.

    function SuperType (name) {
        this.name = name;
        this.colors = ["red","yellow","bule"];
    }
    SuperType.prototype.sayName = function(){
        console.log(this.name)
    }
    function SubType(name,age){
        SuperType.call(this,name);
        this.age = age;
    }
    SubType.prototype = new SuperType();
    SubType.prototype.sayAge = function(){
        console.log(this.age);
    }
    let instancel = new SubType("jackson",22);
    instancel.colors.push("pink");
    instancel.sayName(); // "jackson"
    instancel.sayAge();//22
    console.log(instancel.colors);// ["red", "yellow", "bule", "pink"]
    
    let instance2 = new SubType("bear", 20);
    console.log(instance2.colors); // ["red", "yellow", "bule"]
    instance2.sayName(); // "bear";
    instance2.sayAge(); // 20

У вас есть четкое ощущение в приведенном выше коде, SubType вызывает SuperType и передает имя, а затем определяет возраст своего собственного свойства, а SubType.prototype также назначается экземпляру SuperType. После назначения прототипа к прототипу добавляется метод sayage, таким образом создавая два экземпляра подтипа, каждый из которых имеет свои собственные свойства и может использовать один и тот же метод.

Комбинаторное наследование компенсирует недостатки цепочки прототипов и конструкторов кражи и является наиболее часто используемым шаблоном наследования в js.

паразитарное наследование

Паразитическое наследование состоит в том, чтобы обернуть объект функцией, а затем вернуть вызов функции, эта функция становится экземпляром или объектом, который может добавлять свойства по желанию. object.create() - это принцип.

  // 寄生式继承
    function subobject(obj) {
        let clone = Object(obj);
        clone.sayName = function(){
            console.log("jackson")
        };
        return clone;
    }
    let sub = {
        name:"bear"
    }
    let sup = subobject(sub);
    sup.sayName();//jackson

В этом примере возвращается новый объект на основе подобъекта, возвращаемый объект sup имеет свойства и методы подобъекта, а также новый метод sayName().

Паразитическое наследование также подходит для сценариев, в которых основное внимание уделяется объектам, а не типам и конструкторам. Функция object() не требуется для паразитного наследования, здесь можно использовать любую функцию, возвращающую новый объект.

Обратите внимание, что добавление функций к объектам посредством паразитного наследования может затруднить повторное использование функций, подобно шаблону конструктора.

наследование паразитарного состава

У комбинаторного наследования есть определенная проблема с эффективностью: его конструктор родительского класса всегда вызывается дважды: один раз при создании прототипа класса слов и один раз в конструкторе подкласса. По сути, подклассы просто должны переопределять свои собственные прототипы во время выполнения.

     function inheritPrototype(subType, superType) {
        let prototype = Object(superType.prototype); // 创建对象
        prototype.constructor = subType; // 增强对象
        subType.prototype = prototype; // 赋值对象
    }

Функция inheritPrototype() реализует базовую логику паразитного наследования композиции. Эта функция принимает два параметра: конструктор дочернего класса и конструктор родительского класса. Внутри этой функции первым шагом является создание копии родительского прототипа. Затем задайте для свойства конструктора возвращаемый объект-прототип, чтобы решить проблему потери конструктора по умолчанию из-за переопределения прототипа. Наконец, назначьте вновь созданный объект прототипу подтипа. Как показано в следующем примере, вызов inheritPrototype() может реализовать присвоение прототипа подтипа из предыдущего примера:

function SuperType(name) {
        this.name = name;
        this.colors = ["red", "blue", "green"];
    }
    SuperType.prototype.sayName = function () {
        console.log(this.name);
    };

    function SubType(name, age) {
        SuperType.call(this, name);
        this.age = age;
    }
    inheritPrototype(SubType, SuperType);
    SubType.prototype.sayAge = function () {
        console.log(this.age);
    };

Конструктор SuperType вызывается только один раз, что позволяет избежать ненужных и неиспользуемых свойств в SubType.prototype, поэтому можно сказать, что этот пример более эффективен. И цепочка прототипов остается прежней.

Паразитическое композиционное наследование можно считать лучшим шаблоном для наследования ссылочного типа.

Категории