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

969

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.

TIMEX
fuente
44
Lo que me sorprendió aquí fue requirecrear una carpeta en el mismo directorio en Windows. Tienes que usar el direccionamiento de estilo Unix: en ./mydirlugar de simplemente viejo mydir.
Ben
1
Creé un módulo para importar scripts, exportar a archivo e incluir un módulo desde una node_modulescarpeta externa . npmjs.com/package/node-import Espero que pueda ayudar. ¡Gracias!
Nanang Mahdaen El-Agung

Respuestas:

1416

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
masylum
fuente
101
+1 Bien hecho, incluso limita el código importado a su propio espacio de nombres. Tendré que tomar nota de esto para más tarde.
Evan Plaice
8
Me pregunto si es posible importar scripts externos. require("http://javascript-modules.googlecode.com/svn/functionChecker.js")no parece importar el módulo correctamente. ¿Hay alguna otra forma de importar scripts externos?
Anderson Green el
66
¿Y qué pasa si tengo que pasar la variable a la función Me gusta, bar: function (a, b) {// algún código}
Nishutosh Sharma
55
Como está exponiendo propiedades, usaría exportaciones en lugar de module.exports. Para exportaciones vs módulo. Exportaciones: stackoverflow.com/questions/5311334/…
Granja
44
cómo llamar a la función bar (), dentro de la función foo (), significa cómo acceder a una función con otra
pitu
303

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í.

Udo G
fuente
41
Genial, esto es útil para poner rápidamente JS libs diseñadas para el lado del cliente en una aplicación node.js sin la necesidad de mantener una bifurcación de estilo Node.
Kos
18
Acabo de responder la pregunta original, que trata sobre incluir código, no escribir módulos. El primero puede tener ventajas en ciertas situaciones. Además, su suposición sobre require es incorrecta: el código ciertamente se evalúa, pero permanece en su propio espacio de nombres y no tiene forma de "contaminar" el espacio de nombres del contexto de llamada, por lo tanto, debe evaluarlo () usted mismo. En la mayoría de los casos, usar el método descrito en mi respuesta es una mala práctica, pero no soy yo quien debe decidir si es para TIMEX.
Udo G
14
@EvanPlaice: ¿tiene una mejor sugerencia que realmente responda la pregunta ? Si necesita incluir un archivo que no es un módulo , ¿tiene un enfoque mejor que este?
jalf
8
A veces, cuando necesita incluir, y a veces requiere, son dos conceptos fundamentalmente diferentes en la mayoría de los lenguajes de programación, Nodo JS también. La capacidad de incluir js en su lugar debería ser parte de Node para ser honesto, pero evaluarlo es esencialmente una solución decente. Votado
J. Martin
44
Tenga en cuenta que es incompatible con el uso estricto - como uso estricto restringirá el uso de eval mediante el bloqueo de introducción de nuevas variables a través eval, etc.
timbó
189

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

Nick Panov
fuente
12
¿Cómo esto no tiene más + 1s? Esta es una solución real a lo que hace la pregunta (aunque no sea la 'oficial'). También es un millón de veces más fácil de depurar que eval () porque el nodo puede dar una pila de llamadas útil en lugar de apuntar al archivo real en lugar de simplemente no definido.
user3413723
55
Tenga en cuenta que no puede "usar el modo" estricto "en el módulo importado.
David
1
@Nick Panov: ¡genial! Vale la pena señalar que esto funciona porque thisen una función es el alcance global cuando la función se llama directamente (no está vinculada de ninguna manera).
Udo G
3
esto acaba de cambiar mi vida, no es broma - tenía un archivo 1000+ línea que no podía dividir en partes porque las variables de los diferentes métodos son todos intercorrelacionadas y necesitaría la requiere para estar todos en el mismo ámbito ... require('blah.js')();debe permítanme importarlos a todos en el mismo alcance !!! ¡¡¡Gracias!!!
Sam Johnson
2
¡Este es un gran consejo! Advertencia: si declara la función module.exports utilizando la sintaxis de acceso directo () => {} en lugar de la función estándar () {}, falla. ¡Me llevó una hora descubrir dónde estaba el problema! (Las funciones de flecha no tienen su propia propiedad 'this': developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… )
Ryan Griggs
117

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
Jayaprakash G
fuente
¿Qué versión de js funciona?
Mirv - Matt
39

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 () 
{
};
Marcador de posición
fuente
34

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.

jmparatte
fuente
2
Entiendo lo feo que es este truco, pero seguro que me ayudó.
lindhe
30

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
YouBee
fuente
26

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
    }
Dharmesh
fuente
1
Esto funciona, pero ¿no se supone que debemos usar la sintaxis de los módulos al incluir scripts?
Kokodoko
25

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);
}
Chad Austin
fuente
Encontré vm.runInThisContext en otra respuesta SO, y lo había estado usando, para incluir archivos de código Javascript "vainilla". Luego, sin embargo, traté de usarlo para incluir código que dependía de la funcionalidad del nodo (por ejemplo, "var fs = require ('fs')"), y no funcionó. Sin embargo, en ese caso, las soluciones "eval" señaladas en un par de respuestas sí funcionan.
Dexygen
Pensando esto un poco más, cuando comience a necesitar incluir código que depende de la funcionalidad del nodo, probablemente sea hora de escribir un módulo, aunque la solución de evaluación podría ser el primer paso en ese proceso
Dexygen
Solo uno que funcionó en node.js en 2019
meesern
13

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.

Fernando
fuente
12

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 .

M.Hefny
fuente
11

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.

Jimmy Cuadra
fuente
1
Un ejemplo es mejor que un enlace
tno2007
11

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

Alexandre Mulatinho
fuente
10

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.

Kristianmitk
fuente
10

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 };
Ashish Duklan
fuente
3

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);
usuario11153
fuente
2

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;
Saulo Castelo Sampaio
fuente
2

¿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

Gajender Singh
fuente
2

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.
Weijing Lin
fuente
1

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.

zyexal
fuente
1

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();
suku
fuente
1

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>
Matthew D Auld
fuente
0

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.

DhavalW
fuente
0

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 
StefaDesign
fuente
-3

Utilizar:

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

app.js:

module.exports.<your function> = function () {
    <what should the function do>
}
descifrador
fuente
1
Casi nunca debe usar un directorio completo. Debería considerar usar rutas relativas como:./tools.js
Matthew D Auld