Méthode d'appel utilisant le prototype JavaScript

Est-il possible d'appeler la méthode de base à partir d'une méthode prototype en JavaScript si elle a été remplacée?

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

Je n'ai pas compris exactement ce que vous essayez de faire, mais normalement, la mise en œuvre d'un comportement spécifique à un objet se fait dans le sens suivant:

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

Eh bien, une façon de le faire serait d'enregistrer la méthode de base, puis de l'appeler à partir de la méthode surchargée, comme ceci

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

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

        //do something new

    }else{
        return this._do_base();
    }

};

J'ai bien peur que votre exemple ne fonctionne pas comme vous le pensez. Cette partie:

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

écrase la définition de

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

Étant donné que l'objet nouvellement créé a déjà une propriété "do", il ne recherche pas la chaîne prototypique.

La forme classique d'héritage en Javascript est maladroite et difficile à saisir. Je suggérerais plutôt d'utiliser le modèle d'héritage simple de Douglas Crockford. Comme ça:

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

À mon avis, une manière beaucoup plus claire de gérer les objets, les constructeurs et l'héritage en javascript. Pour en savoir plus, consultez Crockfords Javascript: The good parts .

Je sais que cet article date d'il y a 4 ans, mais à cause de mon expérience en C #, je cherchais un moyen d'appeler la classe de base sans avoir à spécifier le nom de la classe, mais plutôt l'obtenir par une propriété de la sous-classe. Donc mon seul changement à la réponse de Christoph serait

De ceci:

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

Pour ça:

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

si vous définissez une fonction comme celle-ci (en utilisant la POO)

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

il y a deux façons d'appeler une fonction prototype: 1) créer une instance et appeler la fonction objet:

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

et l'autre façon est ... 2) appelle la fonction directement à partir du prototype:

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

Cette solution utilise Object.getPrototypeOf

TestA est super qui a getName

TestBest un enfant qui remplace getNamemais, a aussi getBothNamesqui appelle la superversion de getNameainsi que la childversion

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

Une alternative :

// 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 je comprends bien, vous voulez que la fonctionnalité de base soit toujours exécutée, alors qu'une partie de celle-ci devrait être laissée aux implémentations.

Vous pourriez être aidé par le modèle de conception « méthode modèle ».

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 vous connaissez votre super classe par son nom, vous pouvez faire quelque chose comme ceci:

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

Cela imprimera

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

comme prévu.

Une autre façon avec ES5 est de parcourir explicitement la chaîne de prototypes en utilisant 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()

Non, vous devrez donner à la fonction do dans le constructeur et à la fonction do dans le prototype des noms différents.

De plus, si vous souhaitez remplacer toutes les instances et pas seulement cette instance spéciale, celle-ci peut vous aider.

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

résultat:

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