Question

有一个项目，我有速度编码了一些核心功能，我想把它分成模块。我现在的奋斗是如何将原型从一个原型组合到另一个原型。我的想法是这样的：

(function (window) {
    /* Code for base module with core functions. */
    function CORE () {

    }
    window.CORE = CORE; /* I use different naming in real code ... */

})(window);

(function (CORE) {
    /* Code for module with extending functionality. */
    function MODULE1 () {

    }
    CORE.MODULE1 = MODULE1;

})(window.CORE);

我使用一种创建方法：

(function (window) {

var Core = function (options) {
    return new Core.prototype.init(options);
}

Core.prototype = {
    init : function (options) {
        this.a = options.a;
        return this;
    }
}

Core.prototype.init.prototype = Core.prototype;

Core.prototype.init.prototype.fun1 = function () { }
Core.prototype.init.prototype.fun2 = function () { }
...

window.Core = Core;   /* Optionally = Core.init   */

})(window);

然后是一个模块：

(function (Core) {

var Module1 = Core.Module1 = function (options) {
    return new Module1.prototype.build(options);
}

Module1.prototype = {
    build : function (options) {
        this.a = options.a;
        return this;
    }
}

Module1.prototype.build.prototype = Module1.prototype;

Module1.prototype.build.prototype.fun1 = function () { }
Module1.prototype.build.prototype.fun2 = function () { }
...

Core.Module1    = Module1;
Core.Module1_XO = Module1.prototype.build;

})(window.Core);

现在toString() Core，Core.Module1和Core.Module1_XO的打印件都会生成各自的代码。但是没有约束力，如：

如果我说：

var obj = Core({...});，好的。
obj.Module1({...})，失败。 Object #<Object> has no method Module1
new obj.Module1_XO({...})，失败。 undefined is not a function
Core.Module1({...})，好的，但是从Core中丢失了原型。
new Core.Module1_XO({...})，好的，但是从Core中丢失了原型。
...

似乎有效的一种方法是通过绑定函数更新Core，如下所示：

var obj = Core({...});
var mod1 = Core.Module1({...}, obj); <-- pass obj

// In Module1 constructor:

build : function (options, ref) {
    this.a = options.a;
    ref.bind("Module1", this);
}

// And In Core:

Core.prototype.bind(which, what) {
    this[which] = what;
}

问题是如何在没有此黑客的情况下使用Core更新Module。为什么Core不会更新：

window.Core.Module1 = Module1;

它是否隐藏在Core？

我还尝试在模块的外部范围中绑定，如：

(function (Core) {

  /* ... code ... for Mudule1 */

   Core.bind("Module1", Module1);

}(window.Core);

但这也失败了。 Core没有使用Module中的方法进行更新。

Here is a scramble of a fiddle我搞砸了，（请注意，打印的文字是反向的（前置），不会附加，例如最新的。）。它不是最整洁的代码，它处于编辑的中间位置。（我经常尝试新方法。）

Answer 1

由于以下几个原因，您现在正在做的事情存在问题：

您正在向构造函数（类型）添加模块，而不是对象。
全球状态 - 每个人都得到一个 Module1。

我的建议是使用builder pattern（甚至是调解员）的通用版本。

这可能是它的样子。

Core = (function Core(){
    var modules = [];
    return {
        setModule : function(name,value){ 
            modules.push({name:name,value:value});
        },
        build     : function(options){
             this.a = options.a;
             // now let's add all modules
             modules.forEach(function(module){
                 this[module.name] = new module.value();
             });
        }
    };
});

用法如下：

var app = new Core.build({a:"foo"});
app.a;//"foo"

如果你想添加一个模块，那就像

 function Module1(){
     this.name = "Zimbalabim";
 }
 Core.setModule("Module1",Module1);
 var app = new Core.build({a:"Bar"});
 app.Module1.name;//"Zimbalabim"
 app.a;//"Bar"

当然，更通用的架构允许使用不同的架构创建不同的应用程序（可能使用依赖注入容器）但是我们还没有走得那么远：）

如何组合封闭功能的原型？

1 个答案: