In Node.js, how do I “include” functions from my other files?

In Node.js, how do I “include” functions from my other files?

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’


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.


Solution 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; // => 'function'
console.log(typeof; // => 'function'
console.log(typeof tools.zemba); // => undefined

Solution 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:
  • 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.

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

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


and then


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

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


value: 30

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

Solution 6:

I was also looking for a NodeJS ‘include’ function and I checked the solution proposed by Udo G – see message 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)]);


Sure, that helps.