假设我有一个名为app.js的文件。很简单：
var express = require('express');
var app = express.createServer();
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.get('/', function(req, res){
res.render('index', {locals: {
title: 'NowJS + Express Example'
}});
});
app.listen(8080);
如果我在“tools.js”中有一个函数怎么办？我如何导入它们以在apps.js中使用？
或者......我应该将“工具”变成一个模块，然后需要它吗？ ＆LT;＆LT;看起来很难，我宁愿做tools.js文件的基本导入。
答案 0 :(得分：1229)
您可以要求任何js文件，您只需要声明要公开的内容。
// tools.js
// ========
module.exports = {
foo: function () {
// whatever
},
bar: function () {
// whatever
}
};
var zemba = function () {
}
在你的app文件中：
// app.js
// ======
var tools = require('./tools');
console.log(typeof tools.foo); // => 'function'
console.log(typeof tools.bar); // => 'function'
console.log(typeof tools.zemba); // => undefined
答案 1 :(得分：282)
如果尽管有其他所有答案，你仍然希望传统上包含一个node.js源文件中的文件，你可以使用：
var fs = require('fs');
// file is included here:
eval(fs.readFileSync('tools.js')+'');
+''是将文件内容作为字符串而不是对象获取所必需的（如果您愿意，也可以使用.toString()。）请注意，在大多数情况下，这是不良做法，您应该write a module。但是，在极少数情况下，您的本地上下文/命名空间的污染是您真正想要的。
请注意，这不适用于include()（当您在"strict mode"时），因为“导入”文件中的函数和变量已定义 {{3}通过执行导入的代码。严格模式强制执行由较新版本的语言标准定义的某些规则。这可能是避免此处描述的解决方案的另一个原因。
答案 2 :(得分：163)
您不需要新功能或新模块。 如果您不想使用命名空间，则只需执行您正在调用的模块。
module.exports = function() {
this.sum = function(a,b) { return a+b };
this.multiply = function(a,b) { return a*b };
//etc
}
或任何其他.js，如myController.js：
而不是
var tools = require('tools.js')迫使我们使用命名空间并调用tools.sum(1,2);
我们可以简单地调用
require('tools.js')();
然后
sum(1,2);
在我的情况下，我有一个控制器 ctrls.js
的文件module.exports = function() {
this.Categories = require('categories.js');
}
我可以在Categories
require('ctrls.js')()作为公共类
答案 3 :(得分：90)
创建两个js文件
// File cal.js
module.exports = {
sum: function(a,b) {
return a+b
},
multiply: function(a,b) {
return a*b
}
};
主js文件
// File app.js
var tools = require("./cal.js");
var value = tools.sum(10,20);
console.log("Value: "+value);
输出
value: 30
答案 4 :(得分：39)
这是一个简单明了的解释：
// Include the public functions from 'helpers.js'
var helpers = require('./helpers');
// Let's assume this is the data which comes from the database or somewhere else
var databaseName = 'Walter';
var databaseSurname = 'Heisenberg';
// Use the function from 'helpers.js' in the main file, which is server.js
var fullname = helpers.concatenateNames(databaseName, databaseSurname);
// 'module.exports' is a node.JS specific feature, it does not work with regular JavaScript
module.exports =
{
// This is the function which will be called in the main file, which is server.js
// The parameters 'name' and 'surname' will be provided inside the function
// when the function is called in the main file.
// Example: concatenameNames('John,'Doe');
concatenateNames: function (name, surname)
{
var wholeName = name + " " + surname;
return wholeName;
},
sampleFunctionTwo: function ()
{
}
};
// Private variables and functions which will not be accessible outside this file
var privateFunction = function ()
{
};
答案 5 :(得分：32)
我也在寻找NodeJS'include'功能，我检查了 Udo G 提出的解决方案 - 请参阅消息https://stackoverflow.com/a/8744519/2979590。他的代码不适用于我包含的JS文件。 最后我解决了这个问题：
var fs = require("fs");
function read(f) {
return fs.readFileSync(f).toString();
}
function include(f) {
eval.apply(global, [read(f)]);
}
include('somefile_with_some_declarations.js');
当然，这有帮助。
答案 6 :(得分：24)
Node.js中的vm模块提供了在当前上下文（包括全局对象）中执行JavaScript代码的功能。见http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_filename
请注意，截至今天，vm模块中存在一个错误，该错误会阻止runInThisContext在从新上下文调用时执行此操作。这只有在主程序在新上下文中执行代码然后该代码调用runInThisContext时才有意义。见https://github.com/joyent/node/issues/898
可悲的是，Fernando建议的with（全局）方法对于命名函数不起作用，例如“function foo（）{}”
简而言之，这是一个适合我的include（）函数：
function include(path) {
var code = fs.readFileSync(path, 'utf-8');
vm.runInThisContext(code, path);
}
答案 7 :(得分：23)
说我们要调用功能 ping（）和添加（30,20），它位于 lib.js 文件中 来自 main.js
<强> main.js
lib = require("./lib.js")
output = lib.ping();
console.log(output);
//Passing Parameters
console.log("Sum of A and B = " + lib.add(20,30))
<强> lib.js
this.ping=function ()
{
return "Ping Success"
}
//Functions with parameters
this.add=function(a,b)
{
return a+b
}
答案 8 :(得分：13)
- eval（）不能在函数内部使用，必须在内部调用 全局范围，否则没有函数或变量 可访问（即您无法创建include（）实用程序函数或 类似的东西）。
他是对的，但是有一种方法可以影响函数的全局范围。改善他的榜样：
function include(file_) {
with (global) {
eval(fs.readFileSync(file_) + '');
};
};
include('somefile_with_some_declarations.js');
// the declarations are now accessible here.
希望，这有帮助。
答案 9 :(得分：12)
创建两个文件，例如standard_funcs.js和main.js
1。）standard_funcs.js
// Declaration --------------------------------------
module.exports =
{
add,
subtract
// ...
}
// Implementation ----------------------------------
function add(x, y)
{
return x + y;
}
function subtract(x, y)
{
return x - y;
}
// ...
2。）main.js
// include ---------------------------------------
const sf= require("./standard_funcs.js")
// use -------------------------------------------
var x = sf.add(4,2);
console.log(x);
var y = sf.subtract(4,2);
console.log(y);
输出
6
2
答案 10 :(得分：11)
在我看来，另一种方法是在使用（函数（/ *这里的东西* /）{}调用 require（）函数时执行lib文件中的所有内容）（）; 这样做将使所有这些函数成为全局范围，与 eval（）解决方案完全相同
<强>的src / lib.js
(function () {
funcOne = function() {
console.log('mlt funcOne here');
}
funcThree = function(firstName) {
console.log(firstName, 'calls funcThree here');
}
name = "Mulatinho";
myobject = {
title: 'Node.JS is cool',
funcFour: function() {
return console.log('internal funcFour() called here');
}
}
})();
然后在您的主代码中，您可以通过以下名称调用您的函数：
<强> main.js
require('./src/lib')
funcOne();
funcThree('Alex');
console.log(name);
console.log(myobject);
console.log(myobject.funcFour());
将进行此输出
bash-3.2$ node -v
v7.2.1
bash-3.2$ node main.js
mlt funcOne here
Alex calls funcThree here
Mulatinho
{ title: 'Node.JS is cool', funcFour: [Function: funcFour] }
internal funcFour() called here
undefined
当您调用我的 object.funcFour（）时，请注意未定义，如果您使用 eval（）。希望它有所帮助：）
答案 11 :(得分：10)
您可以将函数放在全局变量中，但最好将工具脚本转换为模块。这真的不太难 - 只需将您的公共API附加到exports对象即可。请查看Understanding Node.js' exports module以获取更多详细信息。
答案 12 :(得分：8)
app.js
let { func_name } = require('path_to_tools.js');
func_name(); //function calling
tools.js
let func_name = function() {
...
//function body
...
};
module.exports = { func_name };
答案 13 :(得分：8)
我只想添加，如果您只需要从 tools.js 导入的某些功能，那么您可以使用node.js支持的destructuring assignment版本< em> 6.4 - 见node.green。
示例： （两个文件都在同一个文件夹中）
<强> tools.js
module.exports = {
sum: function(a,b) {
return a + b;
},
isEven: function(a) {
return a % 2 == 0;
}
};
<强> main.js
const { isEven } = require('./tools.js');
console.log(isEven(10));
输出 true
这也避免了您将这些函数指定为另一个对象的属性，如下所示（常见）赋值：
const tools = require('./tools.js');
您需要致电tools.isEven(10)。
注意：
不要忘记在文件名前加上正确的路径 - 即使两个文件都在同一个文件夹中，也需要以./为前缀
来自Node.js docs：
没有前导'/'，'。/'或'../'来表示文件，模块 必须是核心模块或从node_modules文件夹加载。
答案 14 :(得分：6)
它跟我一样，如下......
<强> Lib1.js
//Any other private code here
// Code you want to export
exports.function1 = function1 (params) {.......};
exports.function2 = function2 (params) {.......};
// Again any private code
现在在 Main.js 文件中，您需要包含 Lib1.js
var mylib = requires('lib1.js');
mylib.function1(params);
mylib.function2(params);
请记得将Lib1.js放在 node_modules文件夹中。
答案 15 :(得分：3)
define({
"data": "XYZ"
});
var fs = require("fs");
var vm = require("vm");
function include(path, context) {
var code = fs.readFileSync(path, 'utf-8');
vm.runInContext(code, vm.createContext(context));
}
// Include file
var customContext = {
"define": function (data) {
console.log(data);
}
};
include('./fileToInclude.js', customContext);
答案 16 :(得分：2)
尝试使用此完整的示例代码。您需要在require中使用app.js方法包含该文件，在其中要包含其他main.js文件的功能，并且该文件应公开那些指定的功能，如下例所示。< / p>
app.js
const mainFile= require("./main.js")
var x = mainFile.add(2,4) ;
console.log(x);
var y = mainFile.multiply(2,5);
console.log(y);
main.js
const add = function(x, y){
return x+y;
}
const multiply = function(x,y){
return x*y;
}
module.exports ={
add:add,
multiply:multiply
}
输出
6
10
答案 17 :(得分：2)
就像你有一个文件abc.txt还有更多？
创建2个文件：fileread.js和fetchingfile.js，然后在fileread.js中编写此代码：
function fileread(filename) {
var contents= fs.readFileSync(filename);
return contents;
}
var fs = require("fs"); // file system
//var data = fileread("abc.txt");
module.exports.fileread = fileread;
//data.say();
//console.log(data.toString());
}
在fetchingfile.js中编写此代码：
function myerror(){
console.log("Hey need some help");
console.log("type file=abc.txt");
}
var ags = require("minimist")(process.argv.slice(2), { string: "file" });
if(ags.help || !ags.file) {
myerror();
process.exit(1);
}
var hello = require("./fileread.js");
var data = hello.fileread(ags.file); // importing module here
console.log(data.toString());
现在，在一个终端： $ node fetchingfile.js --file = abc.txt
您将文件名作为参数传递，而且包括readfile.js中的所有文件，而不是传递它。
由于
答案 18 :(得分：2)
您可以简单地require('./filename')。
例如
// file: index.js
var express = require('express');
var app = express();
var child = require('./child');
app.use('/child', child);
app.get('/', function (req, res) {
res.send('parent');
});
app.listen(process.env.PORT, function () {
console.log('Example app listening on port '+process.env.PORT+'!');
});
// file: child.js
var express = require('express'),
child = express.Router();
console.log('child');
child.get('/child', function(req, res){
res.send('Child2');
});
child.get('/', function(req, res){
res.send('Child');
});
module.exports = child;
请注意：
答案 19 :(得分：2)
这是我迄今为止创造的最佳方式。
var fs = require('fs'),
includedFiles_ = {};
global.include = function (fileName) {
var sys = require('sys');
sys.puts('Loading file: ' + fileName);
var ev = require(fileName);
for (var prop in ev) {
global[prop] = ev[prop];
}
includedFiles_[fileName] = true;
};
global.includeOnce = function (fileName) {
if (!includedFiles_[fileName]) {
include(fileName);
}
};
global.includeFolderOnce = function (folder) {
var file, fileName,
sys = require('sys'),
files = fs.readdirSync(folder);
var getFileName = function(str) {
var splited = str.split('.');
splited.pop();
return splited.join('.');
},
getExtension = function(str) {
var splited = str.split('.');
return splited[splited.length - 1];
};
for (var i = 0; i < files.length; i++) {
file = files[i];
if (getExtension(file) === 'js') {
fileName = getFileName(file);
try {
includeOnce(folder + '/' + file);
} catch (err) {
// if (ext.vars) {
// console.log(ext.vars.dump(err));
// } else {
sys.puts(err);
// }
}
}
}
};
includeFolderOnce('./extensions');
includeOnce('./bin/Lara.js');
var lara = new Lara();
您仍需要告知要导出的内容
includeOnce('./bin/WebServer.js');
function Lara() {
this.webServer = new WebServer();
this.webServer.start();
}
Lara.prototype.webServer = null;
module.exports.Lara = Lara;
答案 20 :(得分：1)
我想出了一个相当粗略的方法来处理HTML模板。与PHP <?php include("navigation.html"); ?>
<强> server.js
var fs = require('fs');
String.prototype.filter = function(search,replace){
var regex = new RegExp("{{" + search.toUpperCase() + "}}","ig");
return this.replace(regex,replace);
}
var navigation = fs.readFileSync(__dirname + "/parts/navigation.html");
function preProcessPage(html){
return html.filter("nav",navigation);
}
var express = require('express');
var app = express();
// Keep your server directory safe.
app.use(express.static(__dirname + '/public/'));
// Sorta a server-side .htaccess call I suppose.
app.get("/page_name/",function(req,res){
var html = fs.readFileSync(__dirname + "/pages/page_name.html");
res.send(preProcessPage(html));
});
<强> page_name.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<title>NodeJS Templated Page</title>
<link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="/css/font-awesome.min.css">
<!-- Scripts Load After Page -->
<script type="text/javascript" src="/js/jquery.min.js"></script>
<script type="text/javascript" src="/js/tether.min.js"></script>
<script type="text/javascript" src="/js/bootstrap.min.js"></script>
</head>
<body>
{{NAV}}
<!-- Page Specific Content Below Here-->
</body>
</html>
<强> navigation.html
<nav></nav>
已加载的页面结果
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<title>NodeJS Templated Page</title>
<link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="/css/font-awesome.min.css">
<!-- Scripts Load After Page -->
<script type="text/javascript" src="/js/jquery.min.js"></script>
<script type="text/javascript" src="/js/tether.min.js"></script>
<script type="text/javascript" src="/js/bootstrap.min.js"></script>
</head>
<body>
<nav></nav>
<!-- Page Specific Content Below Here-->
</body>
</html>
答案 21 :(得分：1)
使用node.js和express.js框架时的另一种方法
var f1 = function(){
console.log("f1");
}
var f2 = function(){
console.log("f2");
}
module.exports = {
f1 : f1,
f2 : f2
}
将其存储在名为s的js文件和statics文件夹
中现在使用功能
var s = require('../statics/s');
s.f1();
s.f2();
答案 22 :(得分：1)
我还在寻找一个包含代码而无需编写模块的选项。使用来自不同项目的相同测试的独立源来获取Node.js服务 - jmparatte的答案为我做了。
好处是，您不会污染命名空间，我不会遇到"use strict";的问题而且效果很好。
这是一个完整的示例：
"use strict";
(function(){
var Foo = function(e){
this.foo = e;
}
Foo.prototype.x = 1;
return Foo;
}())
"use strict";
const fs = require('fs');
const path = require('path');
var SampleModule = module.exports = {
instAFoo: function(){
var Foo = eval.apply(
this, [fs.readFileSync(path.join(__dirname, '/lib/foo.js')).toString()]
);
var instance = new Foo('bar');
console.log(instance.foo); // 'bar'
console.log(instance.x); // '1'
}
}
希望这在某种程度上有所帮助。
答案 23 :(得分：0)
如果您想利用多个CPU和微服务体系结构来加快处理速度，请在分叉进程上使用RPC。
听起来很复杂，但是使用octopus很简单。
这是一个例子：
在tools.js上添加：
const octopus = require('octopus');
var rpc = new octopus('tools:tool1');
rpc.over(process, 'processRemote');
var sum = rpc.command('sum'); // This is the example tool.js function to make available in app.js
sum.provide(function (data) { // This is the function body
return data.a + data.b;
});
在app.js上，添加：
const { fork } = require('child_process');
const octopus = require('octopus');
const toolprocess = fork('tools.js');
var rpc = new octopus('parent:parent1');
rpc.over(toolprocess, 'processRemote');
var sum = rpc.command('sum');
// Calling the tool.js sum function from app.js
sum.call('tools:*', {
a:2,
b:3
})
.then((res)=>console.log('response : ',rpc.parseResponses(res)[0].response));
披露-我是章鱼的作者，并且因为我的类似用例而构建，因为我找不到任何轻量级的库。
答案 24 :(得分：0)
要将“工具”变成一个模块，我一点也不觉得困难。尽管有其他所有答案，我仍然建议使用module.exports：
//util.js
module.exports = {
myFunction: function () {
// your logic in here
let message = "I am message from myFunction";
return message;
}
}
现在我们需要将此导出分配到全局范围（在您的app | index | server.js中）
var util = require('./util');
现在您可以将函数引用为：
//util.myFunction();
console.log(util.myFunction()); // prints in console :I am message from myFunction
答案 25 :(得分：-2)
要在 Unix 环境中以交互方式测试模块 ./test.js，可以使用以下方法：
>> node -e "eval(''+require('fs').readFileSync('./test.js'))" -i
...
答案 26 :(得分：-3)
使用：
var mymodule = require("./tools.js")
app.js：
module.exports.<your function> = function () {
<what should the function do>
}