Javascript 如何声明函数：作为单独的函数或在同一函数中

大家好

问题在于代码风格和代码可维护性，而不是搜索一些错误

假设我正在为node.js创建一些模块。这个模块只导出一个对象，我们称这个对象为FileParser。在文件解析期间，可以有不同的预处理函数。它们非常独特，我不打算在应用程序的其他部分重用它们

因为，此模块仅导出一个函数-我的问题是：

如果我有一些用于此模块的实用程序函数，我应该在导出的函数中定义这些函数，还是应该在该函数之外定义这些函数

基本上，这是：

var FileParser = function(){
}

FileParser.prototype.methodToExport = function(){
  var utilityFunction = function(){
    //do some work, maybe even return values
  }

  //do some other work.
  utilityFunction();

  //do more other work
}
module.exports.FileParser = FileParser;

或者这个：

var FileParser = function(){
}

FileParser.prototype.methodToExport = function(){
  //do some work before calling function
  utilityFunction();
  //do more and more work after calling function
}

function utilityFunction(){
 //body of function goes here, maybe even returning some value
}
module.exports.FileParser = FileParser;

更具可读性的是什么，特别是在实用程序功能很少的情况下

谢谢，

---

-D

在第一种情况下，每次调用methodToExport时都会声明您的函数，在第二种情况下，您将拥有全局函数。也许您可以使用某种闭包：

FileParser.prototype.methodToExport = function() {
    function utilityFunction () { 
        //do some work, maybe even return values
    }
    return function () { // This is the real function, the one which will be export!
        //do some other work
        utilityFunction () ;
        //do more other work
    } ;
} () ;

---

也许有更好的方法，但我会做这样的事情

在第一种情况下，每次调用methodToExport时都会声明您的函数，在第二种情况下，您将拥有全局函数。也许您可以使用某种闭包：

FileParser.prototype.methodToExport = function() {
    function utilityFunction () { 
        //do some work, maybe even return values
    }
    return function () { // This is the real function, the one which will be export!
        //do some other work
        utilityFunction () ;
        //do more other work
    } ;
} () ;

---

也许有更好的方法，但我会做这样的事情

下面的声明称，JavaScript足够灵活，允许这样做，但在我看来不是一个好的实践

var FileParser = function(){

}

FileParser.prototype.methodToExport = function(){
    var utilityFunction = function(){
        //do some work
    }
    utilityFunction();
}

module.exports.FileParser = FileParser;

您在函数中声明和调用，但更清楚的是在FileParser对象的声明中这样做

所以，你们有一个很好的声明模式，由Addy Osmani提出

var FileParser = function(){
    var utilityOne = function(){
    }

    this.methodToExport = function(){
       // do some work 
       utilityOne();
    }
}

module.exports.FileParser = FileParser;

---

这使您能够隐藏一些实用程序函数作为一种封装，并且只显示外部的重要函数。

JavaScript足够灵活，可以允许这样的事情，下面的声明，但在我看来不是一个好的实践

var FileParser = function(){

}

FileParser.prototype.methodToExport = function(){
    var utilityFunction = function(){
        //do some work
    }
    utilityFunction();
}

module.exports.FileParser = FileParser;

您在函数中声明和调用，但更清楚的是在FileParser对象的声明中这样做

所以，你们有一个很好的声明模式，由Addy Osmani提出

var FileParser = function(){
    var utilityOne = function(){
    }

    this.methodToExport = function(){
       // do some work 
       utilityOne();
    }
}

module.exports.FileParser = FileParser;

这使您能够隐藏一些实用函数作为一种封装，并仅显示外部的重要函数。

如果实用函数未用作闭包，即它不访问methodToExport函数中声明的变量，则没有充分的理由在该其他函数中声明它

把它放在外面，它使导出方法更短，因此更可读

因为它驻留在本地模块范围内，所以您甚至不需要担心全局名称空间污染。如果效用函数的数量增长，您可以考虑适当地对它们进行分组，例如使用显示模块模式。

< P>如果UpTyLy函数不被用作闭包，即它不访问MultOutExchange函数中声明的变量，则没有理由在其他函数中声明它。 把它放在外面，它使导出方法更短，因此更可读

---

因为它驻留在本地模块范围内，所以您甚至不需要担心全局名称空间污染。如果效用函数的数量增长，您可以考虑适当地对它们进行分组，例如使用显示模块模式。

您没有问过这个问题，但我建议您将代码放在一个内部，这样在顶层闭包中有一个较小的变量，如：

module.exports.FileParser = (function(){
    var FileParser = function(){};
    // Do your stuff
    return FileParser;
})();

这样就不必为FileParser创建全局变量

至于你问的问题，实用函数应该在导出函数内部还是外部定义，我的答案取决于你是只导出一个函数，还是多个函数。在您的例子中，因为您只导出一个函数，所以我的答案是，只要您有选择，我更喜欢在外部定义的实用程序函数，因为这样它的闭包范围更小。只要您有选择，我的意思是您的实用程序函数没有使用methodToExport中定义的任何东西

在大多数情况下，较小的闭包范围不会产生很大的影响，但下面是一个例子

module.exports.FileParser = (function(){
    var FileParser = function(){};


    FileParser.prototype.methodToExport = function(){
        var longArray = [ /* ... */ ];
        var utilityOne = function(){
            setInterval(function(){
                console.log("Hello");
            },1000);
        };
        utilityOne();
    }
    return FileParser;
})();

在上面的示例中，longArray处于utilityOne的关闭状态，尽管它不是必需的。setTimeout对longArray的引用防止它被垃圾收集

module.exports.FileParser = (function(){
    var FileParser = function(){};
    var utilityOne = function(){
        setInterval(function(){
            console.log("Hello");
        },1000);
    };

    FileParser.prototype.methodToExport = function(){
        var longArray = [ /* ... */ ];
        utilityOne();
    }
    return FileParser;
})();

---

将utilityOne定义移出方法定义会缩小其闭包范围，并允许对longArray进行垃圾收集

您没有问这个问题，但我建议您将代码放在

module.exports.FileParser = (function(){
    var FileParser = function(){};
    // Do your stuff
    return FileParser;
})();

module.exports.FileParser = (function(){
    var FileParser = function(){};
    var utilityOne = function(){
        setInterval(function(){
            console.log("Hello");
        },1000);
    };

    FileParser.prototype.methodToExport = function(){
        var longArray = [ /* ... */ ];
        utilityOne();
    }
    return FileParser;
})();

这样就不必为FileParser创建全局变量

现在，对于您确实提出的问题，实用程序函数是否应该在导出的函数中定义 我的答案取决于您是只导出一个函数，还是导出多个函数。在您的例子中，因为您只导出一个函数，所以我的答案是，只要您有选择，我更喜欢在外部定义的实用程序函数，因为这样它的闭包范围更小。只要您有选择，我的意思是您的实用程序函数没有使用methodToExport中定义的任何东西

在大多数情况下，较小的闭包范围不会产生很大的影响，但下面是一个例子

module.exports.FileParser = (function(){
    var FileParser = function(){};


    FileParser.prototype.methodToExport = function(){
        var longArray = [ /* ... */ ];
        var utilityOne = function(){
            setInterval(function(){
                console.log("Hello");
            },1000);
        };
        utilityOne();
    }
    return FileParser;
})();

在上面的示例中，longArray处于utilityOne的关闭状态，尽管它不是必需的。setTimeout对longArray的引用防止它被垃圾收集

module.exports.FileParser = (function(){
    var FileParser = function(){};
    var utilityOne = function(){
        setInterval(function(){
            console.log("Hello");
        },1000);
    };

    FileParser.prototype.methodToExport = function(){
        var longArray = [ /* ... */ ];
        utilityOne();
    }
    return FileParser;
})();

---

将utilityOne定义移出方法定义会缩小其闭包范围，并允许对longArray进行垃圾收集

我相信第一个例子是错误的，因为你在另一个例子中声明了一个函数，你真的用这种方法吗？你可以用这种方法，特别是当你将它用作回调函数，或者你计划在函数中的多个位置使用它时。每次实例化类时，都会定义函数，而另一个只定义了一次。我不明白readable与此有什么关系，更多的是功能性。在每次重新定义函数的例子中，它可以访问这个函数，而另一个例子则不能。我认为第一个例子是错误的，因为你在另一个例子中声明了一个函数，你真的用这种方法吗？你可以用这种方法，特别是如果你将它用作回调，例如，或者您计划在函数中的多个位置使用in。一个在每次实例化类时定义函数，而另一个只定义一次。我不明白readable与此有什么关系，更多的是功能性。在这个例子中，它每次都被重新定义，它可以访问这个地方，而在另一个地方它不能。嗯，这个例子只是为了说明什么是可能的。让我编辑一下，这样会更清楚：@dimko1是的，正如我所说的，我会在我的post.emmm上添加评论，这个例子只是为了说明什么是可能的。让我编辑一下，这样会更清楚：@dimko1是的，正如我所说的那样，我会在我的帖子上添加评论。添加更多评论：问题更多的是关于你如何组织代码，我试图改进。。。请再看一看。添加更多评论：问题更多的是关于您如何组织代码以改进。。。请再看一次。哦，终于有好答案了。至少我听到了争论，为什么我应该把它放在外面。：哦，终于有好答案了。至少我听到了争论，我为什么要把它放在外面

module.exports.FileParser = (function(){
    var FileParser = function(){};
    var utilityOne = function(){
        setInterval(function(){
            console.log("Hello");
        },1000);
    };

    FileParser.prototype.methodToExport = function(){
        var longArray = [ /* ... */ ];
        utilityOne();
    }
    return FileParser;
})();