JavaScript 中的方法继承

JavaScript 使用原型系统，这与类系统有着根本的不同。这是我第一次认真接触这种语言。我以前玩过它，但这是我第一次构建具有适当 OO、继承、多态等的系统。

从我读到的内容来看，似乎有一些常用的方法可以在 Javascript 中进行成员函数继承。假设您有一个父foo

foo = function(){ this.one = 1; }
foo.prototype.func1 = function(){return this.one;}

MDN JavaScript 继承简介提出了在子上下文中调用父方法的幼稚方法，如下所示。

bar = function(){ foo.call(this); }
bar.prototype = Object.create(foo.prototype);
bar.prototype.func1 = function(){ return this.one + foo.prototype.func1();}

这具有易于理解的优点，但正如此Salsify博客文章中指出的那样，可能会变得繁琐。此博客文章概述了一种替代方法，其中在子原型中定义super属性，并将每个成员函数的名称作为属性附加到该方法。但是，此方法依赖于方法的caller属性，本文指出该方法将很快被弃用。与其重复整篇文章，我认为重要观点的总结是这些

Object.defineProperty(bar.prototype, "super", {
 get: function get() {
  ...
  // methodName is set as a property on each method in an omitted code segment
  methodName = get.caller.methodName; 
  ...
  Object.getPrototypeOf(this.prototype)[methodName]
 }
}

也就是说，您可以在原型的原型中找到具有相同名称的方法。我想知道这是否可以以更简单的方式完成，而无需将方法名称附加为参数，也无需Function.caller.

foo.prototype.super = function(method) {
  superMethod = Object.getPrototypeOf(this.constructor.prototype)[method];
  return superMethod.call(this, Array.prototype.slice.call(arguments, 1));
}
bar.prototype.func1 = function(){ return this.one + super('func1'); }

我在上面做了一些假设，我想验证一些假设。

new bar（）.
1. constructor.prototype === Object.getPrototypeOf（new bar（））
2. 如果上述情况总是正确的，那么一个比另一个更可取吗？
3. Parent 的成员函数将始终存在于子原型的原型中（假设在创建对象后两个原型都没有发生突变）
4. Object.getPrototypeOf（）不是博客所指的ES6中添加的"访问超级方法的语言支持"。
5. 如果 Object.getPrototypeOf（） 不是该语言支持，那是什么？

在看到使用 this 的错误后，它在整个执行过程中不会改变并且始终引用子类的实例，我重新审视并认为我需要这样的东西

Grandfather = function(){};
Grandfather.prototype.function1 = function(){console.log("I am the Grandfather");};
Father = function(){Grandfather.apply(this);};
Father.prototype = Object.create(Grandfather.prototype);
Father.prototype.function1 = function f(){ f.super(); console.log("I am the Father");};
Father.prototype.function1.super = Grandfather.prototype.function1;
Child = function(){Father.apply(this);}
Child.prototype = Object.create(Father.prototype);
Child.prototype.function1 = function f(){ f.super(); console.log("I am the Child");};
Child.prototype.function1.super = Father.prototype.function1;
c = new Child();
c.function1();
// I am the Grandfather
// I am the Father
// I am the Child

所以问题就变成了，如何以某种自动方式为每个函数设置 super 属性？

下面显示了一种方法，它的好处是在对象实例化后添加到原型中的函数仍然能够调用superFunc，而在类扩展时设置super属性的方法如果稍后将函数添加到原型中，则不会设置这样的属性。

此方法的缺点是它只能在单线程环境中工作，并且需要从公共基类继承的功能。它不是线程安全的，因为某些状态保存在实际上是函数的静态变量中。这对我的目的来说很好，因为浏览器仍然有单线程的JavaScript。所有类都继承自包含此方法的某个基类的要求并不是一个巨大的障碍（特别是如果你做了一件"坏事"并将其插入到 Object 的原型中）。

Grandfather.prototype.superFunc = function f(funcName){
  currentPrototype = Object.getPrototypeOf(f.startingPrototype || Object.getPrototypeOf(this));
  f.startingPrototype = currentPrototype;
  return currentPrototype[funcName]();
}
Child.prototype.function2 = function(){this.superFunc('function2'); console.log("Still in the Child");};
Father.prototype.function2 = function(){this.superFunc('function2'); console.log("Still in the Father");};
GrandFather.prototype.function2 = function(){console.log("Still in the Grandfather");};
c = new Child();
c.function2();
// Still in the Grandfather
// Still in the Father
// Still in the Child