如果被覆盖，是否可以从 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
}
};
【问题讨论】：
标签： javascript prototype overriding
我不明白您到底想做什么，但通常按照以下方式实现特定于对象的行为：
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...*/);
}
【讨论】：
一种方法是保存基本方法，然后从覆盖的方法中调用它，就像这样
MyClass.prototype._do_base = MyClass.prototype.do;
MyClass.prototype.do = function(){
if (this.name === 'something'){
//do something new
}else{
return this._do_base();
}
};
【讨论】：
_do_base 存储对之前定义的任何函数的引用。如果没有，那就是undefined。 JavaScript 不是make——表达式永远不会像你建议的那样懒惰地求值。现在，如果从 also 继承的原型使用 _do_base 来存储它认为是其基类型的do 实现，那么你确实有问题。所以，是的，如果使用这种方法，闭包将是一种更好的、继承安全的方式来存储对原始函数实现的引用——尽管这需要使用Function.prototype.call(this)。
恐怕你的例子不像你想的那样起作用。这部分：
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 阅读更多内容。
【讨论】：
base_do 作为一个函数调用，因为这样会丢失原始do 方法中的任何this 绑定。因此，基方法的设置有点复杂，尤其是如果您想使用基对象作为this 而不是子对象来调用它。我会建议类似于base_do.apply(me, arguments)。
var 代替base_do？这是故意的，如果是，为什么？而且，正如@GiulioPiancastelli 所说，这会破坏this 在base_do() 内的绑定，还是该调用会从调用者那里继承this？
var 应该在那里。使用call（或apply）可以让我们正确绑定this。
我知道这篇文章是 4 年前的，但由于我的 C# 背景，我一直在寻找一种方法来调用基类，而不必指定类名，而是通过子类上的属性获取它。所以我对Christoph's answer 的唯一更改是
从这里：
MyClass.prototype.doStuff.call(this /*, args...*/);
到这里：
this.constructor.prototype.doStuff.call(this /*, args...*/);
【讨论】：
this.constructor 可能并不总是指向MyClass。
如果你定义这样的函数（使用 OOP）
function Person(){};
Person.prototype.say = function(message){
console.log(message);
}
调用原型函数有两种方式：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());【讨论】：
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();
};
}
【讨论】：
另一种选择：
// 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);
}
【讨论】：
__proto__（它会改变对象的 [[Prototype]]`）。请改用Object.create(...) 路由。
如果我理解正确，您希望始终执行基本功能，而其中一部分应该留给实现。
“template method”设计模式可能会帮助您。
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 */ }
【讨论】：
如果你知道你的超类的名字，你可以这样做：
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
正如预期的那样。
【讨论】：
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()
【讨论】：
不，您需要为构造函数中的 do 函数和原型中的 do 函数赋予不同的名称。
【讨论】：
此外，如果您想覆盖所有实例而不仅仅是一个特殊实例，这个可能会有所帮助。
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
【讨论】：
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();
【讨论】：