In Node.js, how do I “include” functions from my o

问题:

Let\'s say I have a file called app.js. Pretty simple:

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

What if I have a functions inside \"tools.js\". How would I import them to use in apps.js?

Or...am I supposed to turn \"tools\" into a module, and then require it? << seems hard, I rather do the basic import of the tools.js file.

回答1:

You can require any js file, you just need to declare what you want to expose.

// tools.js
// ========
module.exports = {
  foo: function () {
    // whatever
  },
  bar: function () {
    // whatever
  }
};

var zemba = function () {
}

And in your app file:

// app.js
// ======
var tools = require(\'./tools\');
console.log(typeof tools.foo); // => \'function\'
console.log(typeof tools.bar); // => \'function\'
console.log(typeof tools.zemba); // => undefined

回答2:

If, despite all the other answers, you still want to traditionally include a file in a node.js source file, you can use this:

var fs = require(\'fs\');

// file is included here:
eval(fs.readFileSync(\'tools.js\')+\'\');

• The empty string concatenation +\'\' is necessary to get the file content as a string and not an object (you can also use .toString() if you prefer).
• The eval() can\'t be used inside a function and must be called inside the global scope otherwise no functions or variables will be accessible (i.e. you can\'t create a include() utility function or something like that).

Please note that in most cases this is bad practice and you should instead write a module. However, there are rare situations, where pollution of your local context/namespace is what you really want.

Update 2015-08-06

Please also note this won\'t work with \"use strict\"; (when you are in \"strict mode\") because functions and variables defined in the \"imported\" file can\'t be accessed by the code that does the import. Strict mode enforces some rules defined by newer versions of the language standard. This may be another reason to avoid the solution described here.

回答3:

You need no new functions nor new modules. You simply need to execute the module you\'re calling if you don\'t want to use namespace.

in tools.js

module.exports = function() { 
    this.sum = function(a,b) { return a+b };
    this.multiply = function(a,b) { return a*b };
    //etc
}

in app.js

or in any other .js like myController.js :

instead of

var tools = require(\'tools.js\') which force us to use a namespace and call tools like tools.sum(1,2);

we can simply call

require(\'tools.js\')();

and then

sum(1,2);

in my case I have a file with controllers ctrls.js

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

and I can use Categories in every context as public class after require(\'ctrls.js\')()

回答4:

Create two js files

// File cal.js
module.exports = {
    sum: function(a,b) {
        return a+b
    },
    multiply: function(a,b) {
        return a*b
    }
};

Main js file

// File app.js
var tools = require(\"./cal.js\");
var value = tools.sum(10,20);
console.log(\"Value: \"+value);

Output

value: 30

回答5:

Here is a plain and simple explanation:

Server.js content:

// 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 content:

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

回答6:

I was also looking for a NodeJS \'include\' function and I checked the solution proposed by Udo G - see message https://stackoverflow.com/a/8744519/2979590. His code doesn\'t work with my included JS files. Finally I solved the problem like that:

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\');

Sure, that helps.

回答7:

The vm module in Node.js provides the ability to execute JavaScript code within the current context (including global object). See http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_filename

Note that, as of today, there\'s a bug in the vm module that prevenst runInThisContext from doing the right when invoked from a new context. This only matters if your main program executes code within a new context and then that code calls runInThisContext. See https://github.com/joyent/node/issues/898

Sadly, the with(global) approach that Fernando suggested doesn\'t work for named functions like \"function foo() {}\"

In short, here\'s an include() function that works for me:

function include(path) {
    var code = fs.readFileSync(path, \'utf-8\');
    vm.runInThisContext(code, path);
}

回答8:

say we wants to call function ping() and add(30,20) which is in lib.js file from 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
    }

回答9:

Udo G. said:

• The eval() can\'t be used inside a function and must be called inside the global scope otherwise no functions or variables will be accessible (i.e. you can\'t create a include() utility function or something like that).

He\'s right, but there\'s a way to affect the global scope from a function. Improving his example:

function include(file_) {
    with (global) {
        eval(fs.readFileSync(file_) + \'\');
    };
};

include(\'somefile_with_some_declarations.js\');

// the declarations are now accessible here.

Hope, that helps.

回答10:

Another way to do this in my opinion, is to execute everything in the lib file when you call require() function using (function(/* things here */){})(); doing this will make all these functions global scope, exactly like the eval() solution

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

And then in your main code you can call your functions by name like:

main.js

require(\'./src/lib\')
funcOne();
funcThree(\'Alex\');
console.log(name);
console.log(myobject);
console.log(myobject.funcFour());

Will make this output

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

Pay atention to the undefined when you call my object.funcFour(), it will be the same if you load with eval(). Hope it helps :)

回答11:

You can put your functions in global variables, but it\'s better practice to just turn your tools script into a module. It\'s really not too hard – just attach your public API to the exports object. Take a look at Understanding Node.js\' exports module for some more detail.

回答12:

It worked with me like the following....

Lib1.js

//Any other private code here 

// Code you want to export
exports.function1 = function1 (params) {.......};
exports.function2 = function2 (params) {.......};

// Again any private code

now in the Main.js file you need to include Lib1.js

var mylib = requires(\'lib1.js\');
mylib.function1(params);
mylib.function2(params);

Please remember to put the Lib1.js in node_modules folder.

回答13:

I just want to add, in case you need just certain functions imported from your tools.js, then you can use a destructuring assignment which is supported in node.js since version 6.4 - see node.green.

---

Example: (both files are in the same folder)

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

output: true

---

This also avoids that you assign those functions as properties of another object as its the case in the following (common) assignment:

const tools = require(\'./tools.js\');

where you need to call tools.isEven(10).

---

NOTE:

Don\'t forget to prefix your file name with the correct path - even if both files are in the same folder, you need to prefix with ./

From Node.js docs:

Without a leading \'/\', \'./\', or \'../\' to indicate a file, the module must either be a core module or is loaded from a node_modules folder.

回答14:

Include file and run it in given (non-global) context

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

回答15:

This is the best way i have created so far.

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

You still need to inform what you want to export

includeOnce(\'./bin/WebServer.js\');

function Lara() {
  this.webServer = new WebServer();
  this.webServer.start();
}

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

回答16:

Like you are having a file abc.txt and many more?

Create 2 files: fileread.js and fetchingfile.js, then in fileread.js write this code:

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

In fetchingfile.js write this code:

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

Now, in a terminal: $ node fetchingfile.js --file=abc.txt

You are passing the file name as an argument, moreover include all files in readfile.js instead of passing it.

Thanks

回答17:

You can simple just 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;

Please note that:

1. you can\'t listen PORT on the child file, only parent express module has PORT listener
2. Child is using \'Router\', not parent Express moudle.

回答18:

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

回答19:

I was as well searching for an option to include code without writing modules, resp. use the same tested standalone sources from a different project for a Node.js service - and jmparattes answer did it for me.

The benefit is, you don\'t pollute the namespace, I don\'t have trouble with \"use strict\"; and it works well.

Here a full sample:

Script to load - /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\'
    }

}

Hope this was helpfull somehow.

回答20:

Another method when using node.js and express.js framework

var f1 = function(){
   console.log(\"f1\");
}
var f2 = function(){
   console.log(\"f2\");
}

module.exports = {
   f1 : f1,
   f2 : f2
}

store this in a js file named s and in the folder statics

Now to use the function

var s = require(\'../statics/s\');
s.f1();
s.f2();

回答21:

I\'ve come up with a rather crude method of handling this for HTML templating. Similarly to 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>

Loaded Page Result

<!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>

回答22:

If you\'d like to take advantage of multiple CPUs & Microservice architecture, to speed things up...Use RPCs over forked processes.

Sounds complex, but it\'s simple if you use octopus.

Here\'s an example:

on tools.js add :

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

on app.js, add :

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

disclosure - I am the author of octopus, and built if for a similar usecase of mine, since i couldn\'t find any lightweight libraries.

回答23:

Use:

var mymodule = require(\"./tools.js\")

app.js:

module.exports.<your function> = function () {
    <what should the function do>
}