Método de llamada usando el prototipo JavaScript

Question

¿Es posible llamar al método base desde un método prototipo en JavaScript si se ha redefinido?

MyClass = function(name){ 
    this.name = name; 
    this.do = function() { 
     //do somthing 
    } 
}; 

MyClass.prototype.do = function() { 
    if (this.name === 'something') { 
     //do something new 
    } else { 
     //CALL BASE METHOD 
    } 
}; 

Answer 1

no entendía exactamente lo que estamos tratando de hacer, pero normalmente la aplicación de un comportamiento específico a objetos que se hace a lo largo de estas líneas:

function MyClass(name) { 
    this.name = name; 
} 

MyClass.prototype.doStuff = function() { 
    // generic behaviour 
} 

var myObj = new MyClass('foo'); 

var myObjSpecial = new MyClass('bar'); 
myObjSpecial.doStuff = function() { 
    // do specialised stuff 
    // how to call the generic implementation: 
    MyClass.prototype.doStuff.call(this /*, args...*/); 
} 

Answer 2

Si he entendido bien, desea la funcionalidad de la base siempre se realizará, mientras que una parte de ella se debe dejar a las implementaciones.

Es posible que obtenga ayuda con el patrón de diseño 'template method'.

Base = function() {} 
Base.prototype.do = function() { 
    // .. prologue code 
    this.impldo(); 
    // epilogue code 
} 
// note: no impldo implementation for Base! 

derived = new Base(); 
derived.impldo = function() { /* do derived things here safely */ } 

Answer 3

Bueno, una forma de hacerlo sería ahorro el método de base y luego llamando desde el método sobreescrito, al igual que

MyClass.prototype._do_base = MyClass.prototype.do; 
MyClass.prototype.do = function(){ 

    if (this.name === 'something'){ 

     //do something new 

    }else{ 
     return this._do_base(); 
    } 

}; 

Answer 4

Me temo que su ejemplo no funciona la forma de pensar . Esta parte:

this.do = function(){ /*do something*/ }; 

sobrescribe la definición de

MyClass.prototype.do = function(){ /*do something else*/ }; 

Puesto que el objeto recién creado ya tiene un "hacer" la propiedad, que no se ve en la cadena de prototipos.

La forma clásica de herencia en Javascript es incómoda y difícil de entender. Sugeriría utilizar el patrón de herencia simple Douglas Crockfords en su lugar. De esta manera:

function my_class(name) { 
    return { 
     name: name, 
     do: function() { /* do something */ } 
    }; 
} 

function my_child(name) { 
    var me = my_class(name); 
    var base_do = me.do; 
    me.do = function() { 
     if (this.name === 'something'){ 
      //do something new 
     } else { 
      base_do.call(me); 
     } 
    } 
    return me; 
} 

var o = my_child("something"); 
o.do(); // does something new 

var u = my_child("something else"); 
u.do(); // uses base function 

En mi opinión una manera mucho más clara de la manipulación de objetos, constructores y herencia en JavaScript. Puede leer más en Crockfords Javascript: The good parts.

Answer 5

No, necesitaría dar la función do en el constructor y la función do en el prototipo diferentes nombres.

Answer 6

Sé que esta publicación es de hace 4 años, pero debido a mi historial de C# estaba buscando una forma de llamar a la clase base sin tener que especificar el nombre de la clase, sino obtenerla por una propiedad en la subclase. Así que mi único cambio en Christoph's answer sería

De esta:

MyClass.prototype.doStuff.call(this /*, args...*/); 

A esto:

this.constructor.prototype.doStuff.call(this /*, args...*/); 

Answer 7

function NewClass() { 
    var self = this; 
    BaseClass.call(self);   // Set base class 

    var baseModify = self.modify; // Get base function 
    self.modify = function() { 
     // Override code here 
     baseModify(); 
    }; 
} 

Answer 8

si se define una función como esta (usando programación orientada a objetos)

function Person(){}; 
Person.prototype.say = function(message){ 
    console.log(message); 
} 

allí i s dos formas de llamar a una función prototipo: 1) hacer una instancia y llamar a la función del objeto:

var person = new Person(); 
person.say('hello!'); 

y la otra forma es ...2) se llama a la función directamente del prototipo:

Person.prototype.say('hello there!'); 

Answer 9

Si sabe que su super clase por su nombre, se puede hacer algo como esto:

function Base() { 
} 

Base.prototype.foo = function() { 
    console.log('called foo in Base'); 
} 

function Sub() { 
} 

Sub.prototype = new Base(); 

Sub.prototype.foo = function() { 
    console.log('called foo in Sub'); 
    Base.prototype.foo.call(this); 
} 

var base = new Base(); 
base.foo(); 

var sub = new Sub(); 
sub.foo(); 

Esto imprimirá

called foo in Base 
called foo in Sub 
called foo in Base 

como se esperaba.

Answer 10

Además, si desea anular todas las instancias y no solo esa instancia especial, esta podría ayudar.

function MyClass() {} 

MyClass.prototype.myMethod = function() { 
    alert("doing original"); 
}; 
MyClass.prototype.myMethod_original = MyClass.prototype.myMethod; 
MyClass.prototype.myMethod = function() { 
    MyClass.prototype.myMethod_original.call(this); 
    alert("doing override"); 
}; 

myObj = new MyClass(); 
myObj.myMethod(); 

resultado:

doing original 
doing override 

Answer 11

function MyClass() {} 

MyClass.prototype.myMethod = function() { 
    alert("doing original"); 
}; 
MyClass.prototype.myMethod_original = MyClass.prototype.myMethod; 
MyClass.prototype.myMethod = function() { 
    MyClass.prototype.myMethod_original.call(this); 
    alert("doing override"); 
}; 

myObj = new MyClass(); 
myObj.myMethod(); 

Answer 12

Una alternativa:

// shape 
var shape = function(type){ 
    this.type = type; 
} 
shape.prototype.display = function(){ 
    console.log(this.type); 
} 
// circle 
var circle = new shape('circle'); 
// override 
circle.display = function(a,b){ 
    // call implementation of the super class 
    this.__proto__.display.apply(this,arguments); 
} 

Answer 13

 
Following is the solution that worked for me. It uses Object.getPrototypeOf. 
TestA is super that has getName 
TestB is a child that overrides getName but, also has 
getBothNames that calls the super version of getName as well as the child version 

function TestA() { 
 
    this.count = 1; 
 
} 
 
TestA.prototype.constructor = TestA; 
 
TestA.prototype.getName = function ta_gn() { 
 
    this.count = 2; 
 
    return ' TestA.prototype.getName is called **'; 
 
}; 
 

 
function TestB() { 
 
    this.idx = 30; 
 
    this.count = 10; 
 
} 
 
TestB.prototype = new TestA(); 
 
TestB.prototype.constructor = TestB; 
 
TestB.prototype.getName = function tb_gn() { 
 
    return ' TestB.prototype.getName is called ** '; 
 
}; 
 

 
TestB.prototype.getBothNames = function tb_gbn() { 
 
    return Object.getPrototypeOf(TestB.prototype).getName.call(this) + this.getName() + ' this object is : ' + JSON.stringify(this); 
 
}; 
 

 
var tb = new TestB(); 
 
console.log(tb.getBothNames());

Answer 14

Otra forma con ES5 es atravesar explícitamente la cadena de prototipos utilizando Object.getPrototypeOf(this)

const speaker = { 
    speak:() => console.log('the speaker has spoken') 
} 

const announcingSpeaker = Object.create(speaker, { 
    speak: { 
    value: function() { 
     console.log('Attention please!') 
     Object.getPrototypeOf(this).speak() 
    } 
    } 
}) 

announcingSpeaker.speak()