Javascript 从超类访问子类中定义的静态（类）变量

我有一些类共享相同的方法，并且只通过几个静态（aka class）变量来区分。我的想法是将常用方法放入访问静态变量的基类中

这里有一个有效的解决方案，但它看起来像是一个真正的咳嗽障碍。有没有更好/更惯用的方法

"use strict";

// common code
function Base() { }
Base.prototype.f1 = function() {
    console.log(Object.getPrototypeOf(this).constructor.VAR1); // this feels really really wrong!
}
Base.prototype.f2 = function() {
    console.log(Object.getPrototypeOf(this).constructor.VAR2); // ditto
}

// specialization A
function SubA() {  Base.call(this); }
SubA.prototype = Object.create(Base.prototype);
SubA.prototype.constructor = SubA;
SubA.VAR1 = "suba v1";
SubA.VAR2 = "suba v2";

// specialization B
function SubB() { Base.call(this); }
SubB.prototype = Object.create(Base.prototype);
SubB.prototype.constructor = SubB;
SubB.VAR1 = "subb v1";
SubB.VAR2 = "subb v2";

这与预期的效果一样：

> var a = new SubA();
> var b = new SubB();
> a.f1()
suba v1
undefined
> b.f2()
subb v2
undefined

替代方案 当然，我可以编写方法来封装SubA和SubB之间的差异。语法没有那么复杂，但编写基本上表现为静态变量的方法仍然感觉不对劲：

"use strict";

function Base() { }
Base.prototype.f1 = function() {
    console.log(this.getVar1());
}
Base.prototype.f2 = function() {
    console.log(this.getVar2());
}

function SubA() {  Base.call(this); }
SubA.prototype = Object.create(Base.prototype);
SubA.prototype.constructor = SubA;
SubA.prototype.getVar1 = function() { return 'suba v1'; }
SubA.prototype.getVar2 = function() { return 'suba v2'; }

function SubB() { Base.call(this); }
SubB.prototype = Object.create(Base.prototype);
SubB.prototype.constructor = SubB;
SubB.prototype.getVar1 = function() { return 'subb v1'; }
SubB.prototype.getVar2 = function() { return 'subb v2'; }

> var a = new SubA();
> var b = new SubB();
> a.f1()
suba v1
undefined
> b.f2()
subb v2
undefined

---

将

VAR1

和

VAR2

放在类对象本身而不是它们的原型中有什么特别的原因吗？如果没有，事情就会变得简单得多：

function Base() { }
Base.prototype.f1 = function() {
  console.log(this.VAR1);
};
Base.prototype.f2 = function() {
  console.log(this.VAR2);
};

// specialization A
function SubA() {  Base.call(this); }
SubA.prototype = Object.create(Base.prototype);
SubA.prototype.constructor = SubA;
SubA.prototype.VAR1 = "suba v1";
SubA.prototype.VAR2 = "suba v2";

// specialization B
function SubB() { Base.call(this); }
SubB.prototype = Object.create(Base.prototype);
SubB.prototype.constructor = SubB;
SubB.prototype.VAR1 = "subb v1";
SubB.prototype.VAR2 = "subb v2";

---

上述代码通过了测试。

不确定是否有任何错误。为什么不在基类中添加getVar1和getVar2方法呢？让它返回null。我认为这是正确的答案。出于某种原因，我确信

SubA.prototype.VAR1=“SubA v1”

使SubA的每个实例都分配了额外的内存插槽。但我现在明白这只是一种误解。除非不是：）。原型和其他任何对象一样，只在内存中存在一次，不管类有多少个实例。将其归为“脑泡”。谢谢也许这会帮助其他人。