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

967

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.

TIMEX
quelle
4
Was mich hier requireabschreckte, war ein Ordner im selben Verzeichnis unter Windows. Sie müssen die Adressierung im Unix-Stil verwenden: ./mydirstatt einfach alt mydir.
Ben
1
Ich habe ein Modul erstellt, um Skripte zu importieren, in eine Datei zu exportieren und ein Modul aus einem externen node_modulesOrdner einzuschließen. npmjs.com/package/node-import Hoffe, es kann helfen. Vielen Dank!
Nanang Mahdaen El-Agung

Antworten:

1415

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
Masylum
quelle
101
+1 Gut gemacht, beschränkt den importierten Code sogar auf seinen eigenen Namespace. Ich muss das für später notieren.
Evan Plaice
8
Ich frage mich, ob es möglich ist, externe Skripte zu importieren. require("http://javascript-modules.googlecode.com/svn/functionChecker.js")scheint das Modul nicht richtig zu importieren. Gibt es eine andere Möglichkeit, externe Skripte zu importieren?
Anderson Green
6
Und was ist, wenn ich eine Variable an die Funktion übergeben muss
?
5
Da Sie Eigenschaften verfügbar machen, würde ich Exporte anstelle von module.exports verwenden. Für Exporte vs module.exports: stackoverflow.com/questions/5311334/…
Farm
4
Wie man die Funktionsleiste () aufruft, bedeutet innerhalb der Funktion foo (), wie man auf eine Funktion mit einer anderen zugreift
pitu
303

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 .

Udo G.
quelle
41
Cool, dies ist nützlich, um JS-Bibliotheken, die für den Client entwickelt wurden, schnell und einfach in eine node.js-App zu integrieren, ohne dass eine Gabel im Node-Stil gewartet werden muss.
Kos
18
Ich habe gerade die ursprüngliche Frage beantwortet, bei der es darum geht, Code einzuschließen und keine Module zu schreiben. Ersteres kann in bestimmten Situationen Vorteile haben. Außerdem ist Ihre Annahme über require falsch: Der Code wird sicherlich ausgewertet, bleibt jedoch in seinem eigenen Namespace und kann den Namespace des aufrufenden Kontexts nicht "verschmutzen". Daher müssen Sie ihn selbst auswerten (). In den meisten Fällen ist die Verwendung der in meiner Antwort beschriebenen Methode eine schlechte Praxis, aber nicht ich sollte entscheiden, ob es sich um TIMEX handelt.
Udo G
14
@EvanPlaice: Hast du einen besseren Vorschlag, der die Frage tatsächlich beantwortet ? Wenn Sie eine Datei einfügen müssen, die kein Modul ist , haben Sie einen besseren Ansatz als diesen?
Jalf
8
Es gibt manchmal Fälle, in denen Sie einschließen müssen, und manchmal sind es zwei grundlegend unterschiedliche Konzepte in den meisten Programmiersprachen, auch Node JS. Die Fähigkeit, js an Ort und Stelle einzubeziehen, sollte ehrlich gesagt ein Teil von Node sein, aber die Bewertung ist im Wesentlichen eine anständige Lösung. Upvoted.
J. Martin
4
Beachten Sie, dass dies nicht mit use strict kompatibel ist - da use strict die Verwendung von eval einschränkt, indem die Einführung neuer Variablen durch eval usw.
blockiert wird
189

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

Nick Panov
quelle
12
Wie hat das nicht mehr + 1s? Dies ist eine echte Lösung für die Fragen (wenn auch nicht die "offizielle"). Es ist auch millionenfach einfacher zu debuggen als eval (), da der Knoten einen nützlichen Aufrufstapel geben kann, anstatt auf die eigentliche Datei zu verweisen, anstatt nur undefiniert.
user3413723
5
Beachten Sie, dass Sie im importierten Modul den "strengen" Modus nicht verwenden können.
David
1
@ Nick Panov: genial! Es sollte beachtet werden, dass dies funktioniert, da thisin einer Funktion der globale Bereich ist, in dem die Funktion direkt aufgerufen wird (in keiner Weise gebunden).
Udo G
3
Das hat mein Leben verändert, kein Scherz - ich hatte eine Datei mit mehr als 1000 Zeilen, die ich nicht auflösen konnte, weil die Variablen verschiedener Methoden alle miteinander korreliert sind und die Anforderungen erfordern würden, dass sie alle im selben Bereich liegen ... require('blah.js')();sollten Erlaube mir, sie alle in den gleichen Bereich zu importieren !!! Vielen Dank!!!
Sam Johnson
2
Das ist ein toller Tipp! Vorsichtsmaßnahme: Wenn Sie die Funktion module.exports mit der Verknüpfungssyntax () => {} anstelle der Standarddeklaration function () {} deklarieren, schlägt dies fehl. Ich habe eine Stunde gebraucht, um herauszufinden, wo das Problem liegt! (Pfeilfunktionen haben keine eigene "this" -Eigenschaft: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… )
Ryan Griggs
117

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
Jayaprakash G.
quelle
Welche Version von js funktioniert das?
Mirv - Matt
39

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 () 
{
};
Platzhalter
quelle
34

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.

jmparatte
quelle
2
Ich verstehe, wie hässlich ein Hack ist, aber es hat mir sicher geholfen.
Lindhe
30

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

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
    }
Dharmesh
quelle
1
Das funktioniert, aber sollten wir nicht die Modulsyntax verwenden, wenn wir Skripte einschließen?
Kokodoko
25

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);
}
Chad Austin
quelle
Ich fand vm.runInThisContext in einer anderen SO-Antwort und hatte es verwendet, um "Vanilla" -Javascript-Codedateien einzuschließen. Dann habe ich jedoch versucht, damit Code einzuschließen, der von der Knotenfunktionalität abhängt (z. B. "var fs = require ('fs')"), und es würde nicht funktionieren. In diesem Fall funktioniert jedoch die in einigen Antworten angegebene "Eval" -Lösung (en) tatsächlich.
Dexygen
Wenn Sie etwas mehr darüber nachdenken, wenn Sie Code einfügen müssen, der von der Knotenfunktionalität abhängt, ist es wahrscheinlich an der Zeit, ein Modul zu schreiben, obwohl die
Evaluierungslösung
Nur eine, die 2019 in node.js
funktionierte
13

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.

Fernando
quelle
12

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 .

M.Hefny
quelle
11

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.

Jimmy Cuadra
quelle
1
Ein Beispiel ist besser als ein Link
tno2007
11

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

Alexandre Mulatinho
quelle
10

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.

Kristianmitk
quelle
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
quelle
3

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);
user11153
quelle
2

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

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

Gajender Singh
quelle
2

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

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.

Zyexal
quelle
1

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();
Suku
quelle
1

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

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.

DhavalW
quelle
0

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

Verwenden:

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

app.js:

module.exports.<your function> = function () {
    <what should the function do>
}
Codierer
quelle
1
Sie sollten fast nie ein vollständiges Verzeichnis verwenden. Sie sollten in Betracht ziehen, relative Pfade zu verwenden wie:./tools.js
Matthew D Auld