otra - programacion orientada a objetos javascript pdf

¿Cómo llamar a un método principal desde la clase secundaria en javascript?

Question

He pasado las últimas horas tratando de encontrar una solución a mi problema, pero parece no tener esperanza.

Básicamente, necesito saber cómo llamar a un método principal desde una clase infantil. Todas las cosas que he intentado hasta el momento terminan en que no funcionan o sobreescribiendo el método principal.

Estoy usando el siguiente código para configurar OOP en javascript:

// SET UP OOP
// surrogate constructor (empty function)
function surrogateCtor() {}

function extend(base, sub) {
    // copy the prototype from the base to setup inheritance
    surrogateCtor.prototype = base.prototype;
    sub.prototype = new surrogateCtor();
    sub.prototype.constructor = sub;
}

// parent class
function ParentObject(name) {
    this.name = name;
}
// parent''s methods
ParentObject.prototype = {
    myMethod: function(arg) {
        this.name = arg;
    }
}

// child
function ChildObject(name) {
    // call the parent''s constructor
    ParentObject.call(this, name);
    this.myMethod = function(arg) {
        // HOW DO I CALL THE PARENT METHOD HERE?
        // do stuff
    }
}

// setup the prototype chain
extend(ParentObject, ChildObject);

Necesito llamar primero al método de los padres y luego agregarle más cosas en la clase infantil.

En la mayoría de los lenguajes OOP sería tan simple como llamar a parent.myMethod() Pero realmente no puedo comprender cómo se hace en javascript.

Cualquier ayuda es muy apreciada, ¡gracias!

Answer 1

¿Qué tal algo basado en la idea de Douglas Crockford:

    function Shape(){}

    Shape.prototype.name = ''Shape'';

    Shape.prototype.toString = function(){
        return this.constructor.parent
            ? this.constructor.parent.toString() + '','' + this.name
            : this.name;
    };


    function TwoDShape(){}

    var F = function(){};

    F.prototype = Shape.prototype;

    TwoDShape.prototype = new F();

    TwoDShape.prototype.constructor = TwoDShape;

    TwoDShape.parent = Shape.prototype;

    TwoDShape.prototype.name = ''2D Shape'';


    var my = new TwoDShape();

    console.log(my.toString()); ===> Shape,2D Shape

Answer 2

Así es como se hace: ParentClass.prototype.myMethod();

O si desea llamarlo en el contexto de la instancia actual, puede hacer lo siguiente: ParentClass.prototype.myMethod.call(this)

Lo mismo ParentClass.prototype.myMethod.call(this, arg1, arg2, ..) para llamar a un método padre desde la clase hija con argumentos: ParentClass.prototype.myMethod.call(this, arg1, arg2, ..) * Sugerencia: use apply() lugar de call() para pasar argumentos como una matriz.

Answer 3

Bueno, para hacer esto, no está limitado con la abstracción de Class de ES6. El acceso a los métodos prototipo del constructor padre es posible a través de la propiedad __proto__ (estoy bastante seguro de que habrá otros programadores JS para quejarse de que se depreció) que se depreció pero al mismo tiempo descubrió que en realidad es una herramienta esencial para las necesidades de subclasificación (especialmente para las necesidades de subclases de Array, sin embargo). Entonces, aunque la propiedad __proto__ todavía está disponible en todos los principales motores JS que conozco, ES6 introdujo la funcionalidad Object.getPrototypeOf() en la parte superior. La herramienta super() en la abstracción de Class es un azúcar sintáctico de esto.

Por lo tanto, en caso de que no tenga acceso al nombre del constructor principal y no desee utilizar la abstracción de Class , puede hacer lo siguiente;

function ChildObject(name) {
    // call the parent''s constructor
    ParentObject.call(this, name);
    this.myMethod = function(arg) {
    //this.__proto__.__proto__.myMethod.call(this,arg);
    Object.getPrototypeOf(Object.getPrototypeOf(this)).myMethod.call(this,arg);
    }
}

Answer 4

El estilo de ES6 le permite usar nuevas funciones, como la palabra clave super . super keyword se trata de un contexto de clase principal, cuando se utiliza la sintaxis de las clases de ES6. Como un ejemplo muy simple, pago y envío:

class Foo {
    static classMethod() {
        return ''hello'';
    }
}

class Bar extends Foo {
    static classMethod() {
        return super.classMethod() + '', too'';
    }
}
Bar.classMethod(); // ''hello, too''

Además, puede usar super para llamar al constructor padre:

class Foo {}

class Bar extends Foo {
    constructor(num) {
        let tmp = num * 2; // OK
        this.num = num; // ReferenceError
        super();
        this.num = num; // OK
    }
}

Y, por supuesto, puede usarlo para acceder a las propiedades de la clase padre super.prop . Entonces, usa ES6 y sé feliz.

Answer 5

En el caso del nivel de herencia múltiple, esta función se puede usar como un método super () en otros idiomas. Aquí hay un violín de demostración , con algunas pruebas, puedes usarlo así, dentro del uso de tu método: call_base(this, ''method_name'', arguments);

Hace uso de funciones ES bastante recientes, una compatibilidad con navegadores más antiguos no es garantía. Probado en IE11, FF29, CH35.

/**
 * Call super method of the given object and method.
 * This function create a temporary variable called "_call_base_reference",
 * to inspect whole inheritance linage. It will be deleted at the end of inspection.
 *
 * Usage : Inside your method use call_base(this, ''method_name'', arguments);
 *
 * @param {object} object The owner object of the method and inheritance linage
 * @param {string} method The name of the super method to find.
 * @param {array} args The calls arguments, basically use the "arguments" special variable.
 * @returns {*} The data returned from the super method.
 */
function call_base(object, method, args) {
    // We get base object, first time it will be passed object,
    // but in case of multiple inheritance, it will be instance of parent objects.
    var base = object.hasOwnProperty(''_call_base_reference'') ? object._call_base_reference : object,
    // We get matching method, from current object,
    // this is a reference to define super method.
            object_current_method = base[method],
    // Temp object wo receive method definition.
            descriptor = null,
    // We define super function after founding current position.
            is_super = false,
    // Contain output data.
            output = null;
    while (base !== undefined) {
        // Get method info
        descriptor = Object.getOwnPropertyDescriptor(base, method);
        if (descriptor !== undefined) {
            // We search for current object method to define inherited part of chain.
            if (descriptor.value === object_current_method) {
                // Further loops will be considered as inherited function.
                is_super = true;
            }
            // We already have found current object method.
            else if (is_super === true) {
                // We need to pass original object to apply() as first argument,
                // this allow to keep original instance definition along all method
                // inheritance. But we also need to save reference to "base" who
                // contain parent class, it will be used into this function startup
                // to begin at the right chain position.
                object._call_base_reference = base;
                // Apply super method.
                output = descriptor.value.apply(object, args);
                // Property have been used into super function if another
                // call_base() is launched. Reference is not useful anymore.
                delete object._call_base_reference;
                // Job is done.
                return output;
            }
        }
        // Iterate to the next parent inherited.
        base = Object.getPrototypeOf(base);
    }
}