通过调用祖先函数的 JavaScript 继承

Question

我正在(为我自己)试验一种新型继承。我想用一个参数调用继承的函数，该参数确定返回哪个继承对象。

这里有一个例子来说明我的意思:

function Localizor(type) {
  this.language = "English"
  this.endonym = "English"

  if (window[type]) {
    return new window[type]()
  }
}
Localizor.prototype.native = function native() {
  return "I speak " + this.endonym
}
Localizor.prototype.english = function () {
  return "I speak " + this.language
}


function French () {
  this.language = "French";  
  this.endonym = "français"
}
French.prototype = new Localizor()
French.prototype.native = function french() {
  return "Je parle " + this.endonym
}


function Thai () {
  this.language = "Thai";  
  this.endonym = "ไทย"
}
Thai.prototype = new Localizor()
Thai.prototype.native = function thai() {
  return "พูดภาษา" + this.endonym
}

如果我调用 new Localizor() 时不带任何参数(或带有无效参数)，我会得到一个纯英文对象。如果我用“法语”或“泰语”参数调用它，我会得到一个对象，其中继承者会覆盖一些继承的方法，因此它会说法语或泰语。例如:

var thai = new Localizor("Thai")
var feedback = thai.language + " | " + thai.endonym + " | " + thai.english() + " | " + thai.native()  
console.log(feedback)

这给了我输出 Thai | ไทย |我说泰语 | พูดภาษาไทย.

我有三个问题:
1. 这种类型的继承是否已经在某处记录(有名称)？
2、这样操作有没有危险？
3. 此示例检查是否存在 window[type]，这在浏览器中工作时非常有用。如果这是在 node.js 的模块中，是否有等效的方法来确定模块中是否存在函数？

编辑响应Zero21xxx

这是我发现的一种检测模块中是否存在构造函数的方法，但对我来说它看起来很危险。它有什么风险？有哪些更好的方法可用？

function extend(Child, Parent) {
  function F() {}
  F.prototype = Parent.prototype
  Child.prototype = new F()
  //Child.prototype.constructor = Child
  Child.parent = Parent.prototype
}

function Localizor(type) {
  this.language = "English"
  this.endonym = "English"

  this.French = function français () {
    this.language = "French";  
    this.endonym = "français"
  }
  extend(this.French, this)
  this.French.prototype.native = function french() {
    return "Je parle " + this.endonym
  }

  this.Thai = function ไทย () {
    this.language = "Thai";  
    this.endonym = "ไทย"
  }
  extend(this.Thai, this)
  this.Thai.prototype.native = function thai() {
    return "พูดภาษา" + this.endonym
  }

  if (typeof this[type] === "function") {
   return new this[type]()
  }
}
Localizor.prototype.native = function native() {
  return "I speak " + this.endonym
}
Localizor.prototype.english = function () {
  return "I speak " + this.language
}

module.exports = Localizor

Answer 1

以我的拙见，你应该为 English、French 和 Thai 提供三个独立的构造函数，它们继承自一个公共(public)构造函数(我们称它为语言环境)。它看起来如下:

function Locale(constructor, language, endonym, native) {
    this.constructor = constructor;
    this.language = language;
    this.endonym = endonym;

    this.native = function () {
        return native + this.endonym;
    };
}

Locale.prototype.english = function () {
    return "I speak " + this.language;
};

function English() {}
function French() {}
function Thai() {}

English.prototype = new Locale(English, "English", "English", "I speak ");
French.prototype = new Locale(French, "French", "français", "Je parle ");
Thai.prototype = new Locale(Thai, "Thai", "ไทย", "พูดภาษา");

这导致 separation of concerns :每个构造函数只准确地完成它的目的。仅此而已。现在您可以创建一个 localizer 函数，如下所示:

function localizer(language) {
    switch (language) {
    case "French": return new French;
    case "Thai": return new Thai;
    default: return new English;
    }
}

因此，您需要做的就是调用 localizer 以获得所需的 Locale。