我花了几个小时试图找到解决问题的办法，但似乎毫无希望。
基本上，我需要知道如何从子类调用父方法。
到目前为止，我所尝试的所有东西都以无效或重写父方法而告终。
我使用下面的代码在javascript中设置OOP:
// SET UP OOP
// surrogate constructor (empty function)
function surrogateCtor() {}
function extend(base, sub) {
// copy the prototype from the base to setup inheritance
surrogateCtor.prototype = base.prototype;
sub.prototype = new surrogateCtor();
sub.prototype.constructor = sub;
}
// parent class
function ParentObject(name) {
this.name = name;
}
// parent's methods
ParentObject.prototype = {
myMethod: function(arg) {
this.name = arg;
}
}
// child
function ChildObject(name) {
// call the parent's constructor
ParentObject.call(this, name);
this.myMethod = function(arg) {
// HOW DO I CALL THE PARENT METHOD HERE?
// do stuff
}
}
// setup the prototype chain
extend(ParentObject, ChildObject);
我需要先调用父方法，然后在子类中添加一些更多的东西。
在大多数OOP语言中，调用parent.myMethod()就可以了
但我真的不能理解它是如何在javascript中完成的。
任何帮助都非常感激，谢谢!
Well in order to do this, you are not limited with the Class abstraction of ES6. Accessing the parent constructor's prototype methods is possible through the __proto__ property (I am pretty sure there will be fellow JS coders to complain that it's depreciated) which is depreciated but at the same time discovered that it is actually an essential tool for sub-classing needs (especially for the Array sub-classing needs though). So while the __proto__ property is still available in all major JS engines that i know, ES6 introduced the Object.getPrototypeOf() functionality on top of it. The super() tool in the Class abstraction is a syntactical sugar of this.
因此，如果你没有访问父构造函数的名称，并且不想使用Class抽象，你仍然可以这样做;
function ChildObject(name) {
// call the parent's constructor
ParentObject.call(this, name);
this.myMethod = function(arg) {
//this.__proto__.__proto__.myMethod.call(this,arg);
Object.getPrototypeOf(Object.getPrototypeOf(this)).myMethod.call(this,arg);
}
}
ES6风格允许您使用新功能，如超级关键字。super关键字，当你使用ES6类语法时，它都是关于父类上下文的。作为一个非常简单的例子，签出:
记住:我们不能通过实例方法中的super关键字调用父静态方法。调用方法也应该是静态的。
通过实例方法调用静态方法- TypeError !
类Foo {
static classMethod() {
返回“你好”;
｝
｝
类Bar扩展Foo {
classMethod () {
return super.classMethod() + '， too';
｝
｝
console.log (Bar.classMethod ());// 'hello' -调用继承的静态方法
console.log(())(新酒吧.classMethod ());// 'Uncaught TypeError' -调用一个实例方法
通过super调用静态方法-这是有效的!
类Foo {
static classMethod() {
返回“你好”;
｝
｝
类Bar扩展Foo {
static classMethod() {
return super.classMethod() + '， too';
｝
｝
console.log (Bar.classMethod ());// 'hello, too'
现在，超级上下文基于调用而改变——瞧!
类Foo {
static classMethod() {
返回'hello I am static only';
｝
classMethod () {
返回'hello there I am an instance ';
｝
｝
类Bar扩展Foo {
classMethod () {
return super.classMethod() + '， too';
｝
｝
console.log(())(新酒吧.classMethod ());// "你好，我也是一个实例"
console.log (Bar.classMethod ());// "你好，我是静态的"
同样，你可以使用super来调用父构造函数:
class Foo {}
class Bar extends Foo {
constructor(num) {
let tmp = num * 2; // OK
this.num = num; // ReferenceError
super();
this.num = num; // OK
}
}
当然你也可以用它来访问父类属性super。prop。
所以，使用ES6，快乐吧。
虽然您可以通过父方法的原型调用父方法，但您将需要传递当前的子实例以使用调用、应用或绑定方法。bind方法会创建一个新函数，所以如果你关心性能，我不建议你这样做，除非它只被调用一次。
作为一种替代方法，您可以替换子方法，并在调用原始子方法时将父方法放在实例上。
function proxy(context, parent){
var proto = parent.prototype;
var list = Object.getOwnPropertyNames(proto);
for(var i=0; i < list.length; i++){
var key = list[i];
// Create only when child have similar method name
if(context[key] !== proto[key]){
let currentMethod = context[key];
let parentMethod = proto[key];
context[key] = function(){
context.super = parentMethod;
return currentMethod.apply(context, arguments);
}
}
}
}
// ========= The usage would be like this ==========
class Parent {
first = "Home";
constructor(){
console.log('Parent created');
}
add(arg){
return this.first + ", Parent "+arg;
}
}
class Child extends Parent{
constructor(b){
super();
proxy(this, Parent);
console.log('Child created');
}
// Comment this to call method from parent only
add(arg){
return super.add(arg) + ", Child "+arg;
}
}
var family = new Child();
console.log(family.add('B'));
在多重继承级别的情况下，此函数可以在其他语言中用作super()方法。这是一个演示，一些测试，你可以这样使用它，在你的方法使用:call_base(this， 'method_name'，参数);
它使用了最新的ES功能，与旧浏览器的兼容性不能保证。在IE11, FF29, CH35中测试。
/**
* Call super method of the given object and method.
* This function create a temporary variable called "_call_base_reference",
* to inspect whole inheritance linage. It will be deleted at the end of inspection.
*
* Usage : Inside your method use call_base(this, 'method_name', arguments);
*
* @param {object} object The owner object of the method and inheritance linage
* @param {string} method The name of the super method to find.
* @param {array} args The calls arguments, basically use the "arguments" special variable.
* @returns {*} The data returned from the super method.
*/
function call_base(object, method, args) {
// We get base object, first time it will be passed object,
// but in case of multiple inheritance, it will be instance of parent objects.
var base = object.hasOwnProperty('_call_base_reference') ? object._call_base_reference : object,
// We get matching method, from current object,
// this is a reference to define super method.
object_current_method = base[method],
// Temp object wo receive method definition.
descriptor = null,
// We define super function after founding current position.
is_super = false,
// Contain output data.
output = null;
while (base !== undefined) {
// Get method info
descriptor = Object.getOwnPropertyDescriptor(base, method);
if (descriptor !== undefined) {
// We search for current object method to define inherited part of chain.
if (descriptor.value === object_current_method) {
// Further loops will be considered as inherited function.
is_super = true;
}
// We already have found current object method.
else if (is_super === true) {
// We need to pass original object to apply() as first argument,
// this allow to keep original instance definition along all method
// inheritance. But we also need to save reference to "base" who
// contain parent class, it will be used into this function startup
// to begin at the right chain position.
object._call_base_reference = base;
// Apply super method.
output = descriptor.value.apply(object, args);
// Property have been used into super function if another
// call_base() is launched. Reference is not useful anymore.
delete object._call_base_reference;
// Job is done.
return output;
}
}
// Iterate to the next parent inherited.
base = Object.getPrototypeOf(base);
}
}
