JavaScript prototipini kullanarak yöntem çağırma

Geçersiz kılınmışsa JavaScript'teki bir prototip yönteminden temel yöntemi çağırmak mümkün müdür?

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

Tam olarak ne yapmaya çalıştığınızı anlamadım, ancak normalde nesneye özgü davranışı uygulamak şu satırlar boyunca yapılır:

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

Bunu yapmanın bir yolu, temel yöntemi kaydetmek ve ardından onu geçersiz kılma yönteminden çağırmaktır.

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

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

        //do something new

    }else{
        return this._do_base();
    }

};

Korkarım örneğiniz düşündüğünüz gibi çalışmıyor. Bu kısım:

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

tanımının üzerine yazar

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

Yeni oluşturulan nesne zaten bir "do" özelliğine sahip olduğundan, prototip zincirine bakmaz.

Javascript'teki klasik miras biçimi garip ve anlaşılması zor. Bunun yerine Douglas Crockfords basit kalıtım modelini kullanmanızı öneririm. Bunun gibi:

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

Bence javascript'te nesneleri, yapıcıları ve kalıtımı işlemenin çok daha net bir yolu. Crockfords Javascript: The good parts'da daha fazlasını okuyabilirsiniz .

Bu gönderinin 4 yıl öncesine ait olduğunu biliyorum, ancak C # arka planım nedeniyle, sınıf adını belirtmek yerine alt sınıfta bir özellik tarafından elde etmek zorunda kalmadan temel sınıfı çağırmanın bir yolunu arıyordum. Bu yüzden Christoph'un cevabındaki tek değişikliğim olurdu

Bundan:

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

Buna:

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

bunun gibi bir işlev tanımlarsanız (OOP kullanarak)

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

bir prototip işlevi çağırmanın iki yolu vardır: 1) bir örnek oluşturun ve nesne işlevini çağırın:

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

ve diğer yol ... 2) işlevi doğrudan prototipten çağırmaktır:

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

Bu çözüm kullanır Object.getPrototypeOf

TestA olan süper getName

TestBgeçersiz kılma bir çocuktur getNameama, aynı zamanda sahip getBothNamesolduğu aramaları supersürümü getNameyanı sıra childversiyon

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

Bir alternatif :

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

Doğru anladıysam, Base işlevselliğinin her zaman gerçekleştirilmesini istersiniz, ancak bunun bir parçası uygulamalara bırakılmalıdır.

' Şablon yöntemi ' tasarım modelinden yardım alabilirsiniz .

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

Süper sınıfınızı adıyla biliyorsanız, şöyle bir şey yapabilirsiniz:

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

Bu yazdıracak

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

beklenildiği gibi.

ES5 ile başka bir yol, prototip zincirini açık bir şekilde geçmektir. 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()

Hayır, yapıcıdaki do işlevine ve prototipteki do işlevine farklı adlar vermeniz gerekir.

Ek olarak, yalnızca bir özel örneği değil, tüm örnekleri geçersiz kılmak istiyorsanız , bu yardımcı olabilir.

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

sonuç:

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