Javascript 构造辅助函数

我在两个非常相似但不同的接口之上创建了一个抽象，并且无法确定构造代码的最佳方式，以尽可能保持代码的干涸。因此，我试图将所有类似的代码重构成它们自己的函数，但不确定将这些函数放在何处

当前设置：

var module = function module( API ) {
    var properties,
        doSomething = function doSomething( config ) {
            if (A) {
                foo();
            }
            else if (B) {
                // lotsa bar1 code
            }
            else if (C) {
                // lotsa bar2 code
            }
            else {
                error();
            }
        };
    return {
        // public interface
    };
};

我想将bar1和bar2代码折叠到它自己的函数中，但无法决定将此函数放置在何处。我真的不想通过在它所帮助的函数中声明helper来造成开销，尽管它是最可读的选项

选项A：使辅助函数成为模块的另一个直接方法。 这似乎是最简单的方法，但我不喜欢用函数“污染”我的主模块名称空间 “这不代表模块的方法。” 编辑：“这不代表模块的操作。”

选项B：为所有助手创建一个单独的名称空间。这就是我通常构造这些额外函数的方式，但是我越是使用这个版本，它看起来就越不令人满意

var module = function module( API ) {
    var properties,
        helpers = {
           'bar' : function bar( input ) {
                // help doSomething
            }
        },
        doSomething = function doSomething( config ) {
            if (A) {
                foo();
            }
            else if (B) {
                helpers.bar(B);
            }
            else if (C) {
                helpers.bar(C);
            }
            else {
                error();
            }
        };
    return {
        // public interface
    };
};

选项C：将辅助函数设置为主函数的方法

var module = function module( API ) {
    var properties,
        doSomething = function doSomething( config ) {
            if (A) {
                foo();
            }
            else if (B) {
                doSomething.bar(B);
            }
            else if (C) {
                doSomething.bar(C);
            }
            else {
                error();
            }
        };
    doSomething.bar = function( input ) {
         // help doSomething
    };
    return {
        // public interface
    };
};

选项D是围绕函数创建一个闭包

var module = function module( API ) {
    var properties,
        doSomething = function doSomething( config ) {
            if (A) {
                foo();
            }
            else if (B) {
                doSomething.bar(B);
            }
            else if (C) {
                doSomething.bar(C);
            }
            else {
                error();
            }
        };
    doSomething.bar = function( input ) {
         // help doSomething
    };
    return {
        // public interface
    };
};

---

也许我在这方面考虑得太多了，这完全是一个偏好问题。

你说：“我不喜欢用不代表模块方法的函数“污染”我的主模块名称空间。”这可能是一个哲学问题。。。但是，你认为什么是模块的有效方法？我这样问是因为，如果你简单地声明

bar

，就像

doSomething

（就像你在第二个代码块中所做的那样），

bar

在我看来就成了模块的一种方法。那么，你为什么不想这样做呢？特别是因为你似乎甚至有一个公共界面，你可以确保

bar

保持对外界的

private

？就我个人而言，我使用选项

a

。然后，我返回如下内容：

return{publicName:privateFunction}@HaukeP.，Shilly:你有一个奇怪的哲学：-）对我来说，只有模块导出的是该模块的方法。其他的一切都不重要——这是模块中的本地声明。如果您想构造模块代码以使差异更加明显，我建议将公共方法直接定义为导出对象的属性。@Shilly:我看不出在
doSomething
中声明helper函数时考虑的开销。正如你自己所说，这是最具可读性的选择，所以去吧@犹豫不决：几乎不明显。如果您必须非常关心性能，那么您可能根本不会使用方法调用：-）