假设我有一个叫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中使用?
还是……我应该把“工具”变成一个模块，然后需要它吗?<<似乎很难，我宁愿做tools.js文件的基本导入。
您可以将函数放在全局变量中，但更好的做法是将工具脚本转换为模块。这并不难——只需将您的公共API附加到exports对象。看一看理解Node.js的exports模块，了解更多细节。
你可以要求任何js文件，你只需要声明你想公开什么。
// tools.js
// ========
module.exports = {
foo: function () {
// whatever
},
bar: function () {
// whatever
}
};
var zemba = function () {
}
在你的应用文件中:
// app.js
// ======
var tools = require('./tools');
console.log(typeof tools.foo); // => 'function'
console.log(typeof tools.bar); // => 'function'
console.log(typeof tools.zemba); // => undefined
如果，不管所有其他答案，你仍然想传统地在node.js源文件中包含一个文件，你可以使用这个:
var fs = require('fs');
// file is included here:
eval(fs.readFileSync('tools.js')+'');
为了将文件内容作为字符串而不是对象获取，必须使用空字符串连接+ "(如果您愿意，也可以使用. tostring())。 eval()不能在函数内部使用，必须在全局作用域内调用，否则没有函数或变量可访问(即不能创建include()实用函数或类似的东西)。
请注意，在大多数情况下，这是不好的做法，您应该编写一个模块。然而，在极少数情况下，您真正想要的是对本地上下文/名称空间的污染。
更新2015-08-06
请注意，这对“use strict”无效;(当你处于“严格模式”时)，因为在“导入”文件中定义的函数和变量不能被执行导入的代码访问。严格模式强制执行一些由语言标准的新版本定义的规则。这可能是避免此处描述的解决方案的另一个原因。
Udo G.说:
eval()不能在函数内部使用，必须在函数内部调用 全局作用域，否则没有函数或变量 可访问(即不能创建include()实用函数或 差不多吧)。
他是对的，但是有一种方法可以通过函数来影响全局作用域。改进他的例子:
function include(file_) {
with (global) {
eval(fs.readFileSync(file_) + '');
};
};
include('somefile_with_some_declarations.js');
// the declarations are now accessible here.
希望有帮助。
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(global)方法不适用于“function foo(){}”这样的命名函数。
简而言之，这是一个适用于我的include()函数:
function include(path) {
var code = fs.readFileSync(path, 'utf-8');
vm.runInThisContext(code, path);
}
这是迄今为止我所创造的最好的方法。
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;
我也在寻找NodeJS的“包含”函数，我检查了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');
当然，这很有帮助。
下面是一个简单明了的解释:
Server.js内容:
// 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);
Helpers.js内容:
// '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 ()
{
};
您不需要新的函数或新的模块。 如果不想使用命名空间，只需执行正在调用的模块。
在tools.js
module.exports = function() {
this.sum = function(a,b) { return a+b };
this.multiply = function(a,b) { return a*b };
//etc
}
在app.js
或任何其他。js，如myController.js:
而不是
Var tools = require('tools.js')，这迫使我们使用命名空间并调用工具，如tools.sum(1,2);
我们可以简单地调用
require('tools.js')();
然后
sum(1,2);
在我的情况下，我有一个文件与控制器ctrl .js
module.exports = function() {
this.Categories = require('categories.js');
}
和我可以使用类别在每个上下文后的公共类require('ctrls.js')()
包含文件并在给定的(非全局)上下文中运行它
fileToInclude.js
define({
"data": "XYZ"
});
main.js
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);
假设我们想调用函数ping()和add(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
}
我也在寻找一个选项，包括代码而不编写模块，respp。为Node.js服务使用来自不同项目的相同测试独立源- jmparattes回答为我做了这件事。
这样做的好处是，您不会污染名称空间，我不会遇到“使用严格”的问题;而且效果很好。
以下是完整的样本:
加载脚本- /lib/foo.js
"use strict";
(function(){
var Foo = function(e){
this.foo = e;
}
Foo.prototype.x = 1;
return Foo;
}())
SampleModule - index.js
"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'
}
}
希望这对你有所帮助。
它与我的工作如下....
Lib1.js
//Any other private code here
// Code you want to export
exports.function1 = function(params) {.......};
exports.function2 = function(params) {.......};
// Again any private code
现在在Main.js文件中，你需要包含Lib1.js
var mylib = requires('lib1.js');
mylib.function1(params);
mylib.function2(params);
请记住将Lib1.js放在node_modules文件夹中。
比如你有一个abc.txt文件或者更多?
创建两个文件: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中包含所有文件而不是传递它。
谢谢
使用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();
在我看来，另一种方法是在调用require()函数时执行lib文件中的所有内容，使用(function(/* things here */){})();这样做将使所有这些函数都具有全局作用域，就像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()，它将是相同的。希望能有所帮助。
你可以只需要require('./filename')。
Eg.
// 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;
请注意:
你不能监听子文件的PORT，只有父express模块有PORT监听器 子正在使用“路由器”，而不是父Express moudle。
创建两个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
我只是想补充一点，如果你只需要从你的tools.js中导入某些函数，那么你可以使用解构赋值，这在node.js版本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));
输出:真正的
这也避免了你将这些函数赋值为另一个对象的属性，就像下面(常见)赋值的情况一样:
Const tools = require('./tools.js');
你需要调用tools.isEven(10)。
注意:
不要忘记在文件名前面加上正确的路径——即使两个文件在同一个文件夹中，也需要加上。/前缀
来自Node.js文档:
没有前导'/'，'。/'，或'../'表示一个文件，模块 必须是核心模块或从node_modules文件夹加载。
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 };
Use:
var mymodule = require("./tools.js")
app.js:
module.exports.<your function> = function () {
<what should the function do>
}
创建两个文件，例如app.js和tools.js
app.js
const tools= require("./tools.js")
var x = tools.add(4,2) ;
var y = tools.subtract(4,2);
console.log(x);
console.log(y);
tools.js
const add = function(x, y){
return x+y;
}
const subtract = function(x, y){
return x-y;
}
module.exports ={
add,subtract
}
输出
6
2
要把“工具”变成一个模块，我一点也不觉得困难。尽管有其他的答案，我仍然建议使用module.exports:
//util.js
module.exports = {
myFunction: function () {
// your logic in here
let message = "I am message from myFunction";
return message;
}
}
现在我们需要将这个exports分配到全局作用域(在你的应用程序|index|server.js中)
var util = require('./util');
现在你可以引用和调用函数为:
//util.myFunction();
console.log(util.myFunction()); // prints in console :I am message from myFunction
创建两个JavaScript文件。例如import_functions.js和main.js
1.) import_functions.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("./import_functions.js")
// use -------------------------------------------
var x = sf.add(4,2);
console.log(x);
var y = sf.subtract(4,2);
console.log(y);
输出
6
2
要在Unix环境中交互式地测试模块./test.js，可以使用这样的代码:
>> node -e "eval(''+require('fs').readFileSync('./test.js'))" -i
...
Node基于commonjs模块和最近的esm模块工作。基本上，你应该在独立的.js文件中创建模块，并使用导入/导出(module. js)。导出和要求)。
基于作用域，浏览器上的Javascript工作方式不同。有全局作用域，通过clojures(其他函数中的函数)可以获得私有作用域。
因此，在node中，导出将在其他模块中使用的函数和对象。
在我看来，最干净的方法是在tools.js中:
function A(){
.
.
.
}
function B(){
.
.
.
}
module.exports = {
A,
B
}
然后，在app.js中，只需要如下所示的tools.js: const tools = require("tools");
使用ESM模块系统:
a.js:
export default function foo() {};
export function bar() {};
研究:
import foo, {bar} from './a.js';
