Método de llamada con prototipo de JavaScript

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

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
    }
};

No entendí qué es exactamente lo que está tratando de hacer, pero normalmente la implementación de un comportamiento específico del objeto se realiza de la siguiente manera:

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...*/);
}

Bueno, una forma de hacerlo sería guardar el método base y luego llamarlo desde el método anulado, así

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

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

        //do something new

    }else{
        return this._do_base();
    }

};

Me temo que su ejemplo no funciona como usted piensa. Esta parte:

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

sobrescribe la definición de

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

Dado que el objeto recién creado ya tiene una propiedad "do", no busca la cadena de prototipos.

La forma clásica de herencia en Javascript es torpe y difícil de entender. Sugeriría usar el patrón de herencia simple Douglas Crockfords en su lugar. Me gusta esto:

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 forma mucho más clara de manejar objetos, constructores y herencia en javascript. Puedes leer más en Crockfords Javascript: Las partes buenas .

Sé que esta publicación es de hace 4 años, pero debido a mi experiencia en C #, estaba buscando una manera de llamar a la clase base sin tener que especificar el nombre de la clase, sino obtenerla mediante una propiedad en la subclase. Entonces, mi único cambio en la respuesta de Christoph sería

De esto:

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

A esto:

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

si define una función como esta (usando OOP)

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

Hay dos formas de llamar a una función prototipo: 1) hacer una instancia y llamar a la función objeto

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

y la otra forma es ... 2) está llamando a la función directamente desde el prototipo:

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

Esta solución usa Object.getPrototypeOf

TestA es super que tiene getName

TestBes un hijo que anula getNamepero también tiene getBothNamesque llama tanto la superversión getNamecomo la childversión

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());

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();
    };
}

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);
}

Si entiendo correctamente, desea que la funcionalidad de Base se realice siempre, mientras que una parte de ella debe dejarse a las implementaciones.

Es posible que reciba ayuda del patrón de diseño ' método de plantilla '.

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 */ }

Si conoce su superclase por su nombre, 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.

Otra forma con ES5 es atravesar explícitamente la cadena del prototipo usando 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()

No, necesitaría asignar diferentes funciones a la función do en el constructor y a la función do en los prototipos.

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

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();