En Node.js, ¿cómo "incluyo" funciones de mis otros archivos?

Digamos que tengo un archivo llamado app.js. Bastante 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);

¿Qué pasa si tengo funciones dentro de "tools.js"? ¿Cómo los importaría para usar en apps.js?

O ... ¿se supone que debo convertir las "herramientas" en un módulo y luego requerirlo? << parece difícil, prefiero hacer la importación básica del archivo tools.js.

Puede requerir cualquier archivo js, ​​solo necesita declarar lo que desea exponer.

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

var zemba = function () {
}

Y en su archivo de aplicación:

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

Si, a pesar de todas las otras respuestas, aún desea incluir tradicionalmente un archivo en un archivo fuente node.js, puede usar esto:

var fs = require('fs');

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

• La concatenación de cadenas vacía +''es necesaria para obtener el contenido del archivo como una cadena y no como un objeto (también puede usarlo .toString()si lo prefiere).
• Eval () no se puede usar dentro de una función y se debe llamar dentro del alcance global; de lo contrario, no se podrá acceder a funciones o variables (es decir, no se puede crear una include()función de utilidad o algo así).

Tenga en cuenta que, en la mayoría de los casos, esta es una mala práctica y, en su lugar, debe escribir un módulo . Sin embargo, hay situaciones raras, donde la contaminación de su contexto local / espacio de nombres es lo que realmente desea.

Actualizar 2015-08-06

Tenga en cuenta que esto no funcionará "use strict";(cuando esté en "modo estricto" ) porque el código que realiza la importación no puede acceder a las funciones y variables definidas en el archivo "importado" . El modo estricto impone algunas reglas definidas por las nuevas versiones del estándar de idioma. Esta puede ser otra razón para evitar la solución que se describe aquí.

No necesita nuevas funciones ni nuevos módulos. Simplemente necesita ejecutar el módulo al que está llamando si no desea usar el espacio de nombres.

en tools.js

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

en app.js

o en cualquier otro .js como myController.js:

en vez de

var tools = require('tools.js') que nos obligan a usar un espacio de nombres y herramientas de llamada como tools.sum(1,2);

simplemente podemos llamar

require('tools.js')();

y entonces

sum(1,2);

en mi caso tengo un archivo con controladores ctrls.js

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

y puedo usar Categoriesen cada contexto como clase pública despuésrequire('ctrls.js')()

Crea dos archivos js

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

Archivo js principal

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

Salida de la consola

Value: 30

Aquí hay una explicación clara y simple:

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

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

También estaba buscando una función 'incluir' de NodeJS y verifiqué la solución propuesta por Udo G - vea el mensaje https://stackoverflow.com/a/8744519/2979590 . Su código no funciona con mis archivos JS incluidos. Finalmente resolví el problema así:

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

Claro, eso ayuda.

crear dos archivos, por ejemplo, app.jsytools.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
    }

salida

6
2

decir que quiere llamar a la función de ping () y añadir (30,20) que está en lib.js archivo desde 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
    }

El módulo vm en Node.js proporciona la capacidad de ejecutar código JavaScript dentro del contexto actual (incluido el objeto global). Ver http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_filename

Tenga en cuenta que, a partir de hoy, hay un error en el módulo vm que impide que runInThisContext haga lo correcto cuando se invoca desde un nuevo contexto. Esto solo importa si su programa principal ejecuta código dentro de un nuevo contexto y luego ese código llama a runInThisContext. Ver https://github.com/joyent/node/issues/898

Lamentablemente, el enfoque con (global) que Fernando sugirió no funciona para funciones con nombre como "function foo () {}"

En resumen, aquí hay una función include () que funciona para mí:

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

Udo G. dijo:

• Eval () no se puede usar dentro de una función y se debe llamar dentro del alcance global; de lo contrario, no se podrá acceder a funciones o variables (es decir, no se puede crear una función de utilidad include () o algo así).

Tiene razón, pero hay una manera de afectar el alcance global de una función. Mejorando su ejemplo:

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

include('somefile_with_some_declarations.js');

// the declarations are now accessible here.

Espero que ayude.

Funcionó conmigo como lo siguiente ...

Lib1.js

//Any other private code here 

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

// Again any private code

ahora en el archivo Main.js necesita incluir Lib1.js

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

Recuerde colocar Lib1.js en la carpeta node_modules .

Puede poner sus funciones en variables globales, pero es una mejor práctica simplemente convertir su script de herramientas en un módulo. Realmente no es demasiado difícil: simplemente adjunte su API pública al exportsobjeto. Eche un vistazo al módulo de exportaciones de Node.js para obtener más detalles.

Otra forma de hacer esto en mi opinión, es ejecutar todo en el archivo lib cuando llame a la función require () usando (function (/ * things here * /) {}) (); hacer esto hará que todas estas funciones tengan un alcance global, exactamente como la solución 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');
            }
    }
})();

Y luego, en su código principal, puede llamar a sus funciones por su nombre como:

main.js

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

Hará esta salida

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

Preste atención a lo indefinido cuando llame a mi object.funcFour () , será lo mismo si carga con eval () . Espero eso ayude :)

Solo quiero agregar, en caso de que necesite ciertas funciones importadas de su tools.js , entonces puede usar una asignación de desestructuración que es compatible con node.js desde la versión 6.4 - vea node.green .

Ejemplo : (ambos archivos están en la misma carpeta)

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

salida: true

Esto también evita que asigne esas funciones como propiedades de otro objeto como es el caso en la siguiente asignación (común):

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

donde necesitas llamar tools.isEven(10).

NOTA:

No olvide ponerle el prefijo a su nombre de archivo con la ruta correcta; incluso si ambos archivos están en la misma carpeta, necesita un prefijo con ./

De Node.js docs :

Sin un '/', './' o '../' para indicar un archivo, el módulo debe ser un módulo central o cargarse desde una carpeta 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 };

Incluir archivo y ejecutarlo en un contexto dado (no global)

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

Esta es la mejor manera que he creado hasta ahora.

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

Aún necesita informar lo que desea exportar

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

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

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

¿Como si tuvieras un archivo abc.txty muchos más?

Cree 2 archivos: fileread.jsy fetchingfile.jsluego fileread.jsescriba este código:

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

En fetchingfile.jsescribir este código:

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

Ahora, en una terminal: $ node fetchingfile.js --file = abc.txt

Está pasando el nombre del archivo como argumento, además, incluya todos los archivos en readfile.jslugar de pasarlo.

Gracias

Puedes simplemente simple require('./filename').

P.ej.

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

Tenga en cuenta que:

1. no puede escuchar PORT en el archivo secundario, solo el módulo expreso padre tiene escucha PORT
2. El niño está usando 'Enrutador', no el moudle Express de los padres.

También estaba buscando una opción para incluir código sin escribir módulos, resp. use las mismas fuentes independientes probadas de un proyecto diferente para un servicio Node.js, y la respuesta de jmparatte lo hizo por mí.

El beneficio es que no contaminas el espacio de nombres, no tengo problemas "use strict";y funciona bien.

Aquí una muestra completa :

Script para cargar - /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'
    }

}

Espero que esto haya sido útil de alguna manera.

Otro método cuando se utiliza el framework node.js y express.js

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

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

almacenar esto en un archivo js llamado sy en la carpeta estática

Ahora para usar la función

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

Se me ocurrió un método bastante burdo de manejar esto para la plantilla HTML. Similar a 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>

Resultado de la página cargada

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

Si desea aprovechar la arquitectura de múltiples CPU y microservicios, para acelerar las cosas ... Use RPC sobre procesos bifurcados.

Suena complejo, pero es simple si usas pulpo .

Aquí hay un ejemplo:

en tools.js agregar:

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

en app.js, agregue:

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

divulgación: soy el autor de Octopus, y lo construí para un caso similar mío, ya que no pude encontrar ninguna biblioteca ligera.

Para convertir las "herramientas" en un módulo, no veo nada difícil. A pesar de todas las otras respuestas, todavía recomendaría el uso de module.exports:

//util.js
module.exports = {
   myFunction: function () {
   // your logic in here
   let message = "I am message from myFunction";
   return message; 
  }
}

Ahora necesitamos asignar estas exportaciones al alcance global (en su aplicación | index | server.js)

var util = require('./util');

Ahora puede referirse y llamar a la función como:

//util.myFunction();
console.log(util.myFunction()); // prints in console :I am message from myFunction 

Utilizar:

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

app.js:

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