Aufrufmethode mit JavaScript-Prototyp

Ist es möglich, die Basismethode von einer Prototypmethode in JavaScript aufzurufen, wenn sie überschrieben wurde?

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

Ich habe nicht verstanden, was genau Sie versuchen, aber normalerweise erfolgt die Implementierung objektspezifischen Verhaltens in dieser Richtung:

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

Eine Möglichkeit wäre, die Basismethode zu speichern und sie dann wie folgt über die Overriden-Methode aufzurufen

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

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

        //do something new

    }else{
        return this._do_base();
    }

};

Ich fürchte, Ihr Beispiel funktioniert nicht so, wie Sie denken. Dieser Teil:

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

überschreibt die Definition von

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

Da das neu erstellte Objekt bereits eine "do" -Eigenschaft hat, wird die prototypische Kette nicht nachgeschlagen.

Die klassische Form der Vererbung in Javascript ist unangenehm und schwer zu verstehen. Ich würde vorschlagen, stattdessen Douglas Crockfords einfaches Vererbungsmuster zu verwenden. So was:

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

Meiner Meinung nach eine viel klarere Art, mit Objekten, Konstruktoren und Vererbung in Javascript umzugehen. Sie können mehr in Crockfords Javascript lesen : Die guten Teile .

Ich weiß, dass dieser Beitrag von vor 4 Jahren stammt, aber aufgrund meines C # -Hintergrunds suchte ich nach einer Möglichkeit, die Basisklasse aufzurufen, ohne den Klassennamen angeben zu müssen, sondern ihn über eine Eigenschaft in der Unterklasse abzurufen. Meine einzige Änderung an Christophs Antwort wäre also

Davon:

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

Dazu:

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

wenn Sie eine solche Funktion definieren (mit OOP)

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

Es gibt zwei Möglichkeiten, eine Prototypfunktion aufzurufen: 1) Erstellen Sie eine Instanz und rufen Sie die Objektfunktion auf:

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

und der andere Weg ist ... 2) ruft die Funktion direkt vom Prototyp auf:

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

Diese Lösung verwendet Object.getPrototypeOf

TestA ist super das hat getName

TestBist ein Kind, das überschreibt, getNameaber auch getBothNamesdie superVersion von getNamesowie die childVersion aufruft

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

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

Wenn ich das richtig verstehe, möchten Sie, dass die Basisfunktionalität immer ausgeführt wird, während ein Teil davon den Implementierungen überlassen bleiben sollte.

Möglicherweise hilft Ihnen das Entwurfsmuster " Vorlagenmethode ".

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

Wenn Sie Ihre Superklasse beim Namen kennen, können Sie Folgendes tun:

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

Dies wird gedruckt

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

wie erwartet.

Eine andere Möglichkeit mit ES5 besteht darin, die Prototypenkette mit explizit zu durchlaufen 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()

Nein, Sie müssten der Funktion do im Konstruktor und der Funktion do im Prototyp unterschiedliche Namen geben.

Wenn Sie außerdem alle Instanzen und nicht nur diese eine spezielle Instanz überschreiben möchten , kann diese hilfreich sein.

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

Ergebnis:

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