Node.js
Module exportieren und konsumieren
Suche…
Bemerkungen
Während in Node.js im Allgemeinen alles asynchron ausgeführt wird, gehört require() nicht dazu. Da Module in der Praxis nur einmal geladen werden müssen, ist dies eine Sperroperation und sollte ordnungsgemäß verwendet werden.
Module werden nach dem ersten Laden zwischengespeichert. Wenn Sie ein Modul in der Bearbeitung bearbeiten, müssen Sie dessen Eintrag im Modulcache löschen, um die neuen Änderungen verwenden zu können. Das heißt, selbst wenn ein Modul aus dem Modulcache gelöscht wird, wird das Modul selbst nicht mit Müll gefüllt, daher sollte in Produktionsumgebungen darauf geachtet werden.
Laden und Verwenden eines Moduls
Ein Modul kann "importiert" werden oder anderweitig "erforderlich" von der Funktion require() . Um beispielsweise das mit Node.js gelieferte http Modul zu laden, kann Folgendes verwendet werden:
const http = require('http');
Abgesehen von Modulen, die mit der Laufzeitumgebung ausgeliefert werden, können Sie auch von npm installierte Module, z. Wenn Sie express bereits über npm install express auf Ihrem System npm install express , können Sie einfach Folgendes schreiben:
const express = require('express');
Sie können auch Module hinzufügen, die Sie als Teil Ihrer Anwendung selbst geschrieben haben. In diesem Fall lib.js eine Datei namens lib.js im selben Verzeichnis wie die aktuelle Datei ein:
const mylib = require('./lib');
Beachten Sie, dass Sie die Erweiterung weglassen können, und .js wird davon ausgegangen, dass .js wird. Nachdem Sie ein Modul geladen haben, wird die Variable mit einem Objekt gefüllt, das die aus der erforderlichen Datei veröffentlichten Methoden und Eigenschaften enthält. Ein vollständiges Beispiel:
const http = require('http');
// The `http` module has the property `STATUS_CODES`
console.log(http.STATUS_CODES[404]); // outputs 'Not Found'
// Also contains `createServer()`
http.createServer(function(req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write('<html><body>Module Test</body></html>');
res.end();
}).listen(80);
Ein hallo-world.js-Modul erstellen
Node stellt die Schnittstelle module.exports bereit, um Funktionen und Variablen für andere Dateien module.exports zu machen. Am einfachsten ist es, nur ein Objekt (Funktion oder Variable) zu exportieren, wie im ersten Beispiel gezeigt.
hallo-world.js
module.exports = function(subject) {
console.log('Hello ' + subject);
};
Wenn der gesamte Export nicht ein einzelnes Objekt sein soll, können Funktionen und Variablen als Eigenschaften des exports werden. Die drei folgenden Beispiele veranschaulichen dies auf unterschiedliche Weise:
- hello-venus.js: Die Funktionsdefinition wird separat durchgeführt und dann als Eigenschaft von
module.exports - hello-jupiter.js: Die Funktionsdefinitionen werden direkt als Wert der Eigenschaften von
module.exports - hallo-mars.js: Die Funktionsdefinition wird direkt als
exportsdeklariert.module.exportsist eine kurze Version vonmodule.exports
hallo-venus.js
function hello(subject) {
console.log('Venus says Hello ' + subject);
}
module.exports = {
hello: hello
};
hallo-jupiter.js
module.exports = {
hello: function(subject) {
console.log('Jupiter says hello ' + subject);
},
bye: function(subject) {
console.log('Jupiter says goodbye ' + subject);
}
};
hallo-mars.js
exports.hello = function(subject) {
console.log('Mars says Hello ' + subject);
};
Modul mit Verzeichnisnamen wird geladen
Wir haben ein Verzeichnis namens hello das die folgenden Dateien enthält:
index.js
// hello/index.js
module.exports = function(){
console.log('Hej');
};
main.js
// hello/main.js
// We can include the other files we've defined by using the `require()` method
var hw = require('./hello-world.js'),
hm = require('./hello-mars.js'),
hv = require('./hello-venus.js'),
hj = require('./hello-jupiter.js'),
hu = require('./index.js');
// Because we assigned our function to the entire `module.exports` object, we
// can use it directly
hw('World!'); // outputs "Hello World!"
// In this case, we assigned our function to the `hello` property of exports, so we must
// use that here too
hm.hello('Solar System!'); // outputs "Mars says Hello Solar System!"
// The result of assigning module.exports at once is the same as in hello-world.js
hv.hello('Milky Way!'); // outputs "Venus says Hello Milky Way!"
hj.hello('Universe!'); // outputs "Jupiter says hello Universe!"
hj.bye('Universe!'); // outputs "Jupiter says goodbye Universe!"
hu(); //output 'hej'
Den Cache des Moduls ungültig machen
In der Entwicklung stellen Sie möglicherweise fest, dass die Verwendung von require() auf demselben Modul immer dasselbe Modul zurückgibt, selbst wenn Sie Änderungen an dieser Datei vorgenommen haben. Dies liegt daran, dass Module beim ersten Laden zwischengespeichert werden und alle nachfolgenden Modullasten aus dem Cache geladen werden.
Um dieses Problem zu delete , müssen Sie den Eintrag im Cache delete . Wenn Sie beispielsweise ein Modul geladen haben:
var a = require('./a');
Sie könnten dann den Cache-Eintrag löschen:
var rpath = require.resolve('./a.js');
delete require.cache[rpath];
Und dann nochmal das Modul benötigen:
var a = require('./a');
Beachten Sie, dass dies in der Produktion nicht empfohlen wird, da beim delete nur die Referenz auf das geladene Modul und nicht die geladenen Daten selbst delete werden. Das Modul wird nicht aufgesammelt, daher kann eine falsche Verwendung dieser Funktion zu Speicherlecks führen.
Bauen Sie Ihre eigenen Module
Sie können auch auf ein Objekt verweisen, um Methoden öffentlich zu exportieren und kontinuierlich an dieses Objekt anzuhängen:
const auth = module.exports = {}
const config = require('../config')
const request = require('request')
auth.email = function (data, callback) {
// Authenticate with an email address
}
auth.facebook = function (data, callback) {
// Authenticate with a Facebook account
}
auth.twitter = function (data, callback) {
// Authenticate with a Twitter account
}
auth.slack = function (data, callback) {
// Authenticate with a Slack account
}
auth.stack_overflow = function (data, callback) {
// Authenticate with a Stack Overflow account
}
Um eines dieser Module zu verwenden, benötigen Sie das Modul wie gewohnt:
const auth = require('./auth')
module.exports = function (req, res, next) {
auth.facebook(req.body, function (err, user) {
if (err) return next(err)
req.user = user
next()
})
}
Jedes Modul wird nur einmal gespritzt
NodeJS führt das Modul nur dann aus, wenn Sie es zum ersten Mal benötigen. Alle weiteren erforderlichen Funktionen verwenden dasselbe Objekt erneut, sodass der Code nicht zu einem anderen Zeitpunkt im Modul ausgeführt wird. Außerdem speichert Node die Module beim ersten Laden mithilfe von requir. Dies verringert die Anzahl der Dateilesevorgänge und hilft, die Anwendung zu beschleunigen.
myModule.js
console.log(123) ;
exports.var1 = 4 ;
index.js
var a=require('./myModule') ; // Output 123
var b=require('./myModule') ; // No output
console.log(a.var1) ; // Output 4
console.log(b.var1) ; // Output 4
a.var2 = 5 ;
console.log(b.var2) ; // Output 5
Laden von Modulen aus Knoten_Modulen
Module können require d ohne relative Pfade zu benutzen , indem sie in einem speziellen Verzeichnis namens setzen node_modules .
Zum Beispiel, require ein Modul namens foo aus einer Datei index.js , können Sie die folgende Verzeichnisstruktur verwenden:
index.js
\- node_modules
\- foo
|- foo.js
\- package.json
Module sollten zusammen mit einer package.json Datei in einem package.json abgelegt werden. Das main der package.json Datei sollte für das Modul an den Einspeisepunkt Punkt - das ist die Datei , die importiert wird , wenn ein Anwender require('your-module') . main standardmäßig index.js wenn nicht angegeben. Alternativ können Sie auf Dateien relativ zu Ihrem Modul verweisen, indem Sie einfach den relativen Pfad an den require Aufruf anhängen: require('your-module/path/to/file') .
Die Module können auch werden require d von node_modules Verzeichnissen der Dateisystemhierarchie. Wenn wir die folgende Verzeichnisstruktur haben:
my-project
\- node_modules
|- foo // the foo module
\- ...
\- baz // the baz module
\- node_modules
\- bar // the bar module
wir in der Lage, require Sie das Modul foo aus einer beliebigen Datei innerhalb bar mit require('foo') .
Beachten Sie, dass der Knoten nur mit dem Modul übereinstimmt, das der Datei in der Dateisystemhierarchie am nächsten ist, beginnend mit (dem aktuellen Verzeichnis / den Knotenmodulen der Datei). Knoten ordnet Verzeichnisse auf diese Weise bis zum Dateisystemstammverzeichnis zu.
Sie können entweder neue Module von der npm-Registry oder anderen npm-Registries installieren oder eigene erstellen.
Ordner als Modul
Module können auf mehrere .js-Dateien in demselben Ordner aufgeteilt werden. Ein Beispiel in einem Ordner my_module :
function_one.js
module.exports = function() {
return 1;
}
function_two.js
module.exports = function() {
return 2;
}
index.js
exports.f_one = require('./function_one.js');
exports.f_two = require('./function_two.js');
Ein Modul wie dieses wird verwendet, indem auf den Ordnernamen Bezug genommen wird:
var split_module = require('./my_module');
Beachten Sie, dass der Knoten versucht, ein Modul aus dem Ordner node_modules zu laden, wenn Sie es erforderlich machen, indem Sie ./ oder einen Hinweis auf einen Pfad zu einem Ordner aus dem Argument für die Funktionsanforderung weglassen .
Alternativ können Sie im selben Ordner eine package.json Datei mit folgendem Inhalt erstellen:
{
"name": "my_module",
"main": "./your_main_entry_point.js"
}
Auf diese Weise müssen Sie die Hauptmoduldatei nicht "index" nennen.
