Metodo di chiamata tramite prototipo JavaScript

È possibile chiamare il metodo di base da un metodo prototipo in JavaScript se è stato ignorato?

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

Non ho capito esattamente cosa stai cercando di fare, ma normalmente l'implementazione del comportamento specifico dell'oggetto viene eseguita in questo modo:

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

Beh, un modo per farlo sarebbe salvare il metodo di base e quindi chiamarlo dal metodo overriden, in questo modo

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

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

        //do something new

    }else{
        return this._do_base();
    }

};

Temo che il tuo esempio non funzioni come pensi. Questa parte:

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

sovrascrive la definizione di

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

Poiché l'oggetto appena creato ha già una proprietà "do", non cerca la catena prototipo.

La forma classica di eredità in Javascript è imbarazzante e difficile da comprendere. Suggerirei invece di utilizzare Douglas Crockfords semplice modello di eredità. Come questo:

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

Secondo me un modo molto più chiaro di gestire oggetti, costruttori ed eredità in javascript. Puoi leggere di più in Crockfords Javascript: Le parti buone .

So che questo post risale a 4 anni fa, ma a causa del mio background in C # stavo cercando un modo per chiamare la classe base senza dover specificare il nome della classe ma piuttosto ottenerlo da una proprietà nella sottoclasse. Quindi la mia unica modifica alla risposta di Christoph sarebbe

Da questa:

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

A questa:

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

se si definisce una funzione come questa (usando OOP)

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

Esistono due modi per chiamare una funzione prototipo: 1) creare un'istanza e chiamare la funzione oggetto:

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

e l'altro modo è ... 2) chiama la funzione direttamente dal prototipo:

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

Questa soluzione utilizza Object.getPrototypeOf

TestA è super che ha getName

TestBè un bambino che ha la precedenza getNamema getBothNamesche ha anche la superversione getNamee la childversione

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

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

Se ho capito bene, vuoi che la funzionalità Base sia sempre eseguita, mentre una parte di essa dovrebbe essere lasciata alle implementazioni.

Potresti essere aiutato dal modello di progettazione " metodo modello ".

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

Se conosci la tua super classe per nome, puoi fare qualcosa del genere:

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

Questo stamperà

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

come previsto.

Un altro modo con ES5 è quello di attraversare esplicitamente la catena di prototipi 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, è necessario assegnare nomi diversi alla funzione do nel costruttore e alla funzione do nel prototipo.

Inoltre, se si desidera sovrascrivere tutte le istanze e non solo quella speciale, questa potrebbe essere d'aiuto.

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

risultato:

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