オーバーライドされた場合、JavaScriptのプロトタイプメソッドから基本メソッドを呼び出すことは可能ですか?
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
}
};
私はあなたが何をしようとしているのか正確に理解していませんでしたが、通常、オブジェクト固有の動作の実装はこれらの行に沿って行われます:
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...*/);
}
それを行う1つの方法は、ベースメソッドを保存してから、オーバーライドされたメソッドから呼び出すことです。
MyClass.prototype._do_base = MyClass.prototype.do;
MyClass.prototype.do = function(){
if (this.name === 'something'){
//do something new
}else{
return this._do_base();
}
};
あなたの例はあなたが思うように動かないのではないかと思います。この部分:
this.do = function(){ /*do something*/ };
の定義を上書きします
MyClass.prototype.do = function(){ /*do something else*/ };
新しく作成されたオブジェクトにはすでに「do」プロパティがあるため、プロトタイプチェーンは検索されません。
Javascriptの継承の古典的な形式は扱いにくく、把握するのが困難です。代わりに、Douglas Crockfordsの単純な継承パターンを使用することをお勧めします。このような:
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
私の意見では、javascriptでオブジェクト、コンストラクタ、および継承を処理するはるかに明確な方法です。 Crockfordsで詳細を読むことができます Javascript:The good parts 。
私はこの投稿が4年前のものであることを知っていますが、C#のバックグラウンドのために、クラス名を指定せずにサブクラスのプロパティで取得することなくベースクラスを呼び出す方法を探していました。 Christoph's answer への私の唯一の変更は
これから:
MyClass.prototype.doStuff.call(this /*, args...*/);
これに:
this.constructor.prototype.doStuff.call(this /*, args...*/);
このような関数を定義する場合(OOPを使用)
function Person(){};
Person.prototype.say = function(message){
console.log(message);
}
プロトタイプ関数を呼び出すには2つの方法があります。1)インスタンスを作成し、オブジェクト関数を呼び出します。
var person = new Person();
person.say('hello!');
他の方法は... 2)プロトタイプから直接関数を呼び出すことです:
Person.prototype.say('hello there!');
このソリューションはObject.getPrototypeOf
を使用します
TestA
は、getName
を持つスーパーです
TestB
は、getName
をオーバーライドする子ですが、getBothNames
のsuper
バージョンとgetName
バージョンを呼び出すchild
も持っています
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());
別の方法:
// 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);
}
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();
};
}
私が正しく理解していれば、ベース機能を常に実行する必要がありますが、その一部は実装に任せる必要があります。
「 テンプレートメソッド 」デザインパターンが役立つ場合があります。
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 */ }
ES5の別の方法は、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()
名前でスーパークラスを知っている場合は、次のようなことができます。
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();
これは印刷されます
called foo in Base
called foo in Sub
called foo in Base
予想通り。
さらに、1つの特別なインスタンスだけでなく、すべてのインスタンスをオーバーライドするが必要な場合は、これが役立つ場合があります。
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();
結果:
doing original
doing override
いいえ、コンストラクターのdo関数とプロトタイプのdo関数に異なる名前を付ける必要があります。