Wie füge ich in Node.js Funktionen aus meinen anderen Dateien ein?

Angenommen, ich habe eine Datei namens app.js. Ziemlich einfach:

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

Was ist, wenn ich Funktionen in "tools.js" habe? Wie würde ich sie importieren, um sie in apps.js zu verwenden?

Oder ... soll ich "Werkzeuge" in ein Modul verwandeln und es dann benötigen? << scheint schwierig, ich mache lieber den Basisimport der Datei tools.js.

Sie können jede js-Datei benötigen, Sie müssen nur deklarieren, was Sie verfügbar machen möchten.

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

var zemba = function () {
}

Und in Ihrer App-Datei:

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

Wenn trotz aller anderen Antworten, möchten Sie noch traditionell umfassen eine Datei in einer node.js Quelldatei, können Sie diese verwenden:

var fs = require('fs');

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

• Die Verkettung leerer Zeichenfolgen +''ist erforderlich, um den Dateiinhalt als Zeichenfolge und nicht als Objekt abzurufen (Sie können ihn auch verwenden, .toString()wenn Sie dies bevorzugen).
• Eval () kann nicht innerhalb einer Funktion verwendet werden und muss innerhalb des globalen Bereichs aufgerufen werden, da sonst keine Funktionen oder Variablen verfügbar sind (dh Sie können keine include()Dienstprogrammfunktion oder ähnliches erstellen ).

Bitte beachten Sie, dass dies in den meisten Fällen eine schlechte Praxis ist und Sie stattdessen ein Modul schreiben sollten . Es gibt jedoch seltene Situationen, in denen die Verschmutzung Ihres lokalen Kontexts / Namespace das ist, was Sie wirklich wollen.

Update 2015-08-06

Bitte beachten Sie auch, dass dies nicht funktioniert "use strict";(wenn Sie sich im "strengen Modus" befinden ), da der Code, der den Import ausführt, nicht auf Funktionen und Variablen zugreifen kann, die in der "importierten" Datei definiert sind . Der strikte Modus erzwingt einige Regeln, die in neueren Versionen des Sprachstandards definiert sind. Dies kann ein weiterer Grund sein, die hier beschriebene Lösung zu vermeiden .

Sie benötigen weder neue Funktionen noch neue Module. Sie müssen lediglich das Modul ausführen, das Sie aufrufen, wenn Sie keinen Namespace verwenden möchten.

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.

oder in anderen .js wie myController.js:

anstatt

var tools = require('tools.js') die uns zwingen, einen Namespace zu verwenden und Tools wie aufzurufen tools.sum(1,2);

wir können einfach anrufen

require('tools.js')();

und dann

sum(1,2);

In meinem Fall habe ich eine Datei mit den Controllern ctrls.js

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

und ich kann Categoriesin jedem Kontext als öffentliche Klasse danach verwendenrequire('ctrls.js')()

Erstellen Sie zwei JS-Dateien

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

Haupt-js-Datei

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

Konsolenausgabe

Value: 30

Hier ist eine einfache Erklärung:

Server.js Inhalt:

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

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

Ich suchte auch nach einer NodeJS-Include-Funktion und überprüfte die von Udo G vorgeschlagene Lösung - siehe Nachricht https://stackoverflow.com/a/8744519/2979590 . Sein Code funktioniert nicht mit meinen enthaltenen JS-Dateien. Schließlich habe ich das Problem so gelöst:

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

Klar, das hilft.

Erstellen Sie zwei Dateien, z. B. app.jsundtools.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
    }

Ausgabe

6
2

sagen will , wir Funktion aufrufen ping () und fügen (30,20) , die in ist lib.js aus der Datei 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
    }

Das vm-Modul in Node.js bietet die Möglichkeit, JavaScript-Code im aktuellen Kontext (einschließlich des globalen Objekts) auszuführen. Siehe http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_filename

Beachten Sie, dass es ab heute einen Fehler im VM-Modul gibt, der verhindert, dass runInThisContext beim Aufrufen aus einem neuen Kontext das Richtige tut. Dies ist nur wichtig, wenn Ihr Hauptprogramm Code in einem neuen Kontext ausführt und dieser Code dann runInThisContext aufruft. Siehe https://github.com/joyent/node/issues/898

Leider funktioniert der von Fernando vorgeschlagene with (globale) Ansatz nicht für benannte Funktionen wie "function foo () {}".

Kurz gesagt, hier ist eine include () - Funktion, die für mich funktioniert:

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

Udo G. sagte:

• Das eval () kann nicht innerhalb einer Funktion verwendet werden und muss innerhalb des globalen Bereichs aufgerufen werden, da sonst keine Funktionen oder Variablen verfügbar sind (dh Sie können keine include () - Dienstprogrammfunktion oder ähnliches erstellen).

Er hat Recht, aber es gibt eine Möglichkeit, den globalen Umfang einer Funktion zu beeinflussen. Sein Beispiel verbessern:

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

include('somefile_with_some_declarations.js');

// the declarations are now accessible here.

Ich hoffe, das hilft.

Es hat bei mir wie folgt funktioniert ....

Lib1.js

//Any other private code here 

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

// Again any private code

jetzt in der main.js Datei benötigen Sie einschließen Lib1.js

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

Bitte denken Sie daran, die Datei Lib1.js im Ordner node_modules abzulegen .

Sie können Ihre Funktionen in globale Variablen einfügen. Es empfiehlt sich jedoch, das Tool-Skript einfach in ein Modul umzuwandeln. Es ist wirklich nicht zu schwer - hängen Sie einfach Ihre öffentliche API an das exportsObjekt an. Schauen Sie sich auf Verständnis Node.js Exporte Modul für etwas detaillierter.

Eine andere Möglichkeit, dies zu tun, besteht meiner Meinung nach darin, alles in der lib-Datei auszuführen, wenn Sie die Funktion require () mit (function (/ * things here * /) {}) () aufrufen . Dadurch werden alle diese Funktionen global erweitert, genau wie bei eval () Lösung

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

Und dann können Sie in Ihrem Hauptcode Ihre Funktionen beim Namen nennen wie:

main.js

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

Wird diese Ausgabe machen

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 zum undefined , wenn Sie meinen Anruf object.funcFour () , es wird das gleiche sein , wenn Sie mit laden eval () . Ich hoffe es hilft :)

Ich möchte nur hinzufügen, falls Sie nur bestimmte Funktionen benötigen, die aus Ihrer tools.js importiert wurden , können Sie eine Destrukturierungszuweisung verwenden, die in node.js seit Version 6.4 unterstützt wird - siehe node.green .

Beispiel : (beide Dateien befinden sich im selben Ordner)

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

Ausgabe: true

Dadurch wird auch vermieden, dass Sie diese Funktionen als Eigenschaften eines anderen Objekts zuweisen, wie dies bei der folgenden (allgemeinen) Zuweisung der Fall ist:

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

wo Sie anrufen müssen tools.isEven(10).

HINWEIS:

Vergessen Sie nicht, Ihrem Dateinamen den richtigen Pfad voranzustellen - auch wenn sich beide Dateien im selben Ordner befinden, müssen Sie ein Präfix verwenden ./

Aus Node.js Dokumenten :

Ohne ein führendes '/', './' oder '../' zur Angabe einer Datei muss das Modul entweder ein Kernmodul sein oder wird aus einem Ordner node_modules geladen.

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

Fügen Sie die Datei ein und führen Sie sie im angegebenen (nicht globalen) Kontext aus

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

Dies ist der beste Weg, den ich bisher geschaffen habe.

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

Sie müssen noch mitteilen, was Sie exportieren möchten

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

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

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

Wie haben Sie eine Datei abc.txtund viele mehr?

Erstellen 2 - Dateien: fileread.jsund fetchingfile.jsdann in dem fileread.jsCode schreiben:

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.jsSchreib diesen 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());

Jetzt in einem Terminal: $ node fetchingfile.js --file = abc.txt

Sie übergeben den Dateinamen als Argument, schließen außerdem alle Dateien ein, readfile.jsanstatt ihn zu übergeben.

Vielen Dank

Sie können einfach nur require('./filename').

Z.B.

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

Bitte beachte, dass:

1. Sie können PORT für die untergeordnete Datei nicht anhören, nur das übergeordnete Express-Modul verfügt über den PORT-Listener
2. Das Kind verwendet 'Router', nicht das übergeordnete Express-Moudle.

Ich suchte auch nach einer Option, um Code einzuschließen, ohne Module zu schreiben. Verwenden Sie dieselben getesteten eigenständigen Quellen aus einem anderen Projekt für einen Node.js-Dienst - und die Antwort von jmparatte hat es für mich getan.

Der Vorteil ist, dass Sie den Namespace nicht verschmutzen, ich habe keine Probleme damit "use strict";und es funktioniert gut.

Hier ein vollständiges Beispiel:

Zu ladendes Skript - /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'
    }

}

Hoffe das war irgendwie hilfreich.

Eine andere Methode bei Verwendung des Frameworks node.js und express.js

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

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

Speichern Sie dies in einer JS-Datei mit dem Namen s und in der Ordnerstatik

Verwenden Sie nun die Funktion

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

Ich habe mir eine ziemlich grobe Methode ausgedacht, um dies für HTML-Vorlagen zu handhaben. Ähnlich wie bei 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));
});

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

Ergebnis der geladenen Seite

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

Wenn Sie die Vorteile mehrerer CPUs und der Microservice-Architektur nutzen möchten, um die Arbeit zu beschleunigen ... Verwenden Sie RPCs über gegabelte Prozesse.

Klingt komplex, ist aber einfach, wenn Sie Octopus verwenden .

Hier ist ein Beispiel:

auf tools.js hinzufügen:

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

Fügen Sie in app.js Folgendes hinzu:

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

Offenlegung - Ich bin der Autor von Octopus und habe es für einen ähnlichen Anwendungsfall von mir gebaut, da ich keine leichtgewichtigen Bibliotheken finden konnte.

Um "Werkzeuge" in ein Modul zu verwandeln, sehe ich überhaupt nicht schwer. Trotz aller anderen Antworten würde ich die Verwendung von module.exports empfehlen:

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

Jetzt müssen wir diese Exporte dem globalen Bereich zuordnen (in Ihrer app | index | server.js).

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

Jetzt können Sie die Funktion wie folgt bezeichnen und aufrufen:

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

Verwenden:

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

app.js:

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