在 Node.js 中，如何从其他文件中“包含”函数？

您可以要求任何 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() 实用函数或类似的东西）。

请注意，在大多数情况下，这是不好的做法，您应该改为write a module。但是，在极少数情况下，您真正想要的是污染本地上下文/命名空间。

2015-08-06 更新

另请注意，这不适用于 "use strict";（当您在 "strict mode" 中时），因为执行导入的代码在“导入”文件 can't be accessed 中定义函数和变量。严格模式强制执行由较新版本的语言标准定义的一些规则。这可能是避免此处描述的解决方案的另一个原因。

您不需要新功能或新模块。如果您不想使用命名空间，您只需要执行您正在调用的模块。

在工具.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);

就我而言，我有一个带有控制器 ctrls.js 的文件

module.exports = function() {
    this.Categories = require('categories.js');
}

在 require('ctrls.js')() 之后，我可以在每个上下文中将 Categories 用作公共类

创建两个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

创建两个文件，例如 app.js 和 tools.js

应用程序.js

const tools= require("./tools.js")


var x = tools.add(4,2) ;

var y = tools.subtract(4,2);


console.log(x);
console.log(y);

工具.js

 const add = function(x, y){
        return x+y;
    }
 const subtract = function(x, y){
            return x-y;
    }
    
    module.exports ={
        add,subtract
    }

输出

6
2

这是一个简单明了的解释：

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 () 
{
};

我还在寻找 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');

当然，这有帮助。

创建两个 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

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);
}

假设我们要调用 main.js 的 lib.js 文件中的函数 ping() 和 add(30,20)

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
    }

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.

希望，这有帮助。

应用程序.js

let { func_name } = require('path_to_tools.js');
func_name();    //function calling

工具.js

let func_name = function() {
    ...
    //function body
    ...
};

module.exports = { func_name };

在我看来，另一种方法是在调用 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()时注意undefined，用eval()加载也是一样。希望能帮助到你 ：）

它对我有用，如下所示....

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 文件夹中。

您可以将您的函数放在全局变量中，但最好将您的工具脚本变成一个模块。这真的不是太难 - 只需将您的公共 API 附加到 exports 对象。查看 Understanding Node.js' exports module 了解更多详细信息。

我只想补充一点，如果您只需要从 tools.js 导入的某些功能，那么您可以使用 node.js 自版本 6.4destructuring assignment em> - 见 node.green。

module.exports = {
    sum: function(a,b) {
        return a + b;
    },
    isEven: function(a) {
        return a % 2 == 0;
    }
};

const { isEven } = require('./tools.js');

console.log(isEven(10));