我有一组 JavaScript“类”，其中基类定义函数，然后由继承类共享。它正在工作，并且设置如下:

var ThingA = function(name) {
    this.name = name;
};

ThingA.prototype = {
    sayHi: function() {
        alert('Hi, ' + this.name + '!');
    }
};


var ThingB = function() {
    ThingA.call(this, 'Charlie');
};

ThingB.prototype = new ThingA();
ThingB.prototype.constructor = ThingB;

var instanceOfB = new ThingB();
instanceOfB.sayHi();   // alerts 'Hi, Charlie!'

出于我无法控制的原因，我的公司在编写 JavaScript 时更喜欢遵循这种模式:

SomeClass = function() {

    // "Private" functions go here

    function somePrivateMethod() { 
        ...
    }

    return {

        // "Public" methods go here
        somePublicMethod: function() { ... }

    };
}();

现在，就目前情况而言，这很好，并且适用于许多情况。但它更像是一种功能性风格。只有一个“类”实例，一切都是静态的。

我被要求修改我的工作代码以更符合我公司喜欢的风格。所以我的问题是，有没有办法从包装在工厂类中的类继承？它看起来像这样:

FactoryClassA = function() {

    var ThingA = function(name) {
        this.name = name;
    };

    ThingA.prototype = {
        sayHi: function() {
            alert('Hi, ' + this.name + '!');
        }
    };

    return {
         createThingA: function(name) {
             return new ThingA(name);
         }
    };
}();


FactoryClassB = function() {

    // Define a ThingB class that inherits from ThingA somehow

    return {
         createThingB: function() {
             return new ThingB();
         }
    };
}();


var instanceOfB = FactoryClassB.createThingB();
instanceOfB.sayHi();   // should alert 'Hi, Charlie!'

有没有一种方法可以定义 FactoryClassB 中的 ThingB 继承自 FactoryClassA 中的 ThingA >? 感谢 this question ，我知道我无法完全像这样做到。我正在考虑使用一种方法来扩展给定的类......不知何故？

This answer看起来很接近，但我无法弄清楚如何修改该示例以适应我的具体情况的细节。我愿意稍微改变我公司的惯常模式，但我至少可以更接近它吗？

更新 1

为了回应 Adam 的评论，只是向工厂类添加一个参数，这里是我卡住的地方:

ThingB.prototype = new ThingA();
ThingB.prototype.constructor = ThingB;

如果我只是将参数传递给工厂类方法，我无法弄清楚如何调整这些行以使其工作。

最佳答案

以下是(我相信)您正在寻找的内容:

FactoryClassA = function() {
    var ThingA = function(name) {
       this.name = name;
    };
    ThingA.prototype = {
        sayHi: function() {
            console.log('Hi, ' + this.name + '!');
        }
    };
    // Add the constructor back to the prototype
    // (see explanation below)
    ThingA.prototype.constructor = ThingA;

    return {
        createThingA: function(name) {
            return new ThingA(name);
        }
    };
}();

FactoryClassB = function() {
    // Bootstrapping:
    // Capture the instance, as we'll need it to set up the prototype
    var baseInstance = new FactoryClassA.createThingA();
    // Capture the constructor
    var baseConstructor = baseInstance.constructor;
    // Keep a reference to the base prototype
    var baseProto = baseConstructor.prototype;

    function ThingB(name) {
        // Call base constructor, along with our args
        baseConstructor.call(this, name);
    };
    ThingB.prototype = baseInstance;
    ThingB.prototype.constructor = ThingB;

    ThingB.prototype.sayHi = function() {
        console.log('here I am');
        // call the base class `sayHi`
        baseProto.sayHi.call(this);
    };

    return {
        createThingB: function(name) {
            return new ThingB(name);
        }
    };
}();

// Testing
var foo = FactoryClassB.createThingB("Indeed");
foo.sayHi();

// Output:
//   here I am 
//   hi indeed

解释:

在FactoryClassA ，这一行是必要的:

ThingA.prototype.constructor = ThingA;

请注意，JS 中的每个原型(prototype)都是通过对其构造函数的引用自动创建的。例如，当您执行以下操作时:

function T(){}

T.prototype已经有一个名为 constructor 的属性指向T .

但是，在您执行 ThingA 时，你通过做 ThingA.prototype = { ... } 来重置整个原型(prototype).因此，您现在丢失了对其构造函数的引用。在 99% 的情况下它是可以的，并且不会有任何负面影响(这可能是大多数开发人员倾向于忘记它的原因)。但是，在继承的情况下，这可能是必要的。

现在，在 FactoryClassB 内，我们需要做一些引导:

var baseInstance = new FactoryClassA.createThingA();
var baseConstructor = baseInstance.constructor;
var baseProto = baseConstructor.prototype;

注意最后两行，因为它们对于在此设计模式中实现继承至关重要。首先，自 ThingA的构造函数可以通过原型(prototype)( ThingA.prototype.constructor = ThingA )访问，这意味着给定 ThingA 的实例，我们可以直接检索它的构造函数。由于构造函数是函数本身，并且每个函数都有对其原型(prototype)的引用，我们可以保留 ThingA.prototype 的引用。与 baseConstructor.prototype .

接下来是关键部分，我们在这里设置继承链:

function ThingB(name) {
    // Call the base constructor
    baseConstructor.call(this, name);
};
ThingB.prototype = baseInstance;
ThingB.prototype.constructor = ThingB;

上面的最后一行非常重要，因为它告诉原型(prototype)它的构造函数是什么，否则它仍然会指向ThingA。 .

这就是原型(prototype)继承。

旁注:

您可能会看到上面的内容是如何变得非常乏味、有点怪诞和重复的。因此，您可能需要考虑像 Fiber.js 这样的继承库它遵循您想要的封装模式(以及一些奖励，如 mixins 和装饰器)。 免责声明:我编写了这个库。

关于javascript - 如何扩展在 JavaScript 中闭包后面定义的类？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22254590/