Was ist der Zweck von Node.js module.exports und wie verwenden Sie es?
Ich kann anscheinend keine Informationen dazu finden, aber es scheint ein ziemlich wichtiger Teil von Node.js zu sein, wie ich es oft im Quellcode sehe.
Gemäß der Node.js-Dokumentation :
module
Ein Verweis auf das aktuelle
module
. Insbesonderemodule.exports
ist das gleiche wie das export Objekt. Sehensrc/node.js
für weitere Informationen.
Das hilft aber nicht wirklich.
Was genau macht module.exports
und was wäre ein einfaches Beispiel?
module.exports
ist das Objekt, das tatsächlich als Ergebnis eines require
-Aufrufs zurückgegeben wird.
Die Variable exports
ist anfänglich auf dasselbe Objekt festgelegt (d. H. Es handelt sich um eine Kurzbezeichnung "Alias"). In diesem Modulcode würden Sie normalerweise Folgendes schreiben:
var myFunc1 = function() { ... };
var myFunc2 = function() { ... };
exports.myFunc1 = myFunc1;
exports.myFunc2 = myFunc2;
zum Exportieren (oder "Exponieren") der internen Funktionen myFunc1
und myFunc2
.
Und im aufrufenden Code würden Sie Folgendes verwenden:
var m = require('./mymodule');
m.myFunc1();
dabei zeigt die letzte Zeile, wie require
das Ergebnis ist (in der Regel) nur ein einfaches Objekt, auf dessen Eigenschaften zugegriffen werden kann.
Hinweis: Wenn Sie exports
überschreiben, wird auf module.exports
nicht mehr verwiesen. Wenn Sie also exports
ein neues Objekt (oder eine Funktionsreferenz) zuweisen möchten, sollten Sie dieses neue Objekt auch module.exports
zuweisen.
Es ist erwähnenswert, dass der Name, der dem exports
-Objekt hinzugefügt wird, nicht mit dem internen Namen des Moduls für den von Ihnen hinzugefügten Wert übereinstimmen muss.
var myVeryLongInternalName = function() { ... };
exports.shortName = myVeryLongInternalName;
// add other objects, functions, as required
gefolgt von:
var m = require('./mymodule');
m.shortName(); // invokes module.myVeryLongInternalName
Dies wurde bereits beantwortet, aber ich wollte einige Klarstellungen hinzufügen ...
Sie können sowohl exports
als auch module.exports
verwenden, um Code wie folgt in Ihre Anwendung zu importieren:
var mycode = require('./path/to/mycode');
Der grundlegende Anwendungsfall (z. B. im ExpressJS-Beispielcode) besteht darin, dass Sie Eigenschaften für das Objekt exports
in einer .js-Datei festlegen, die Sie dann mit require()
importieren.
In einem einfachen Zählbeispiel könnten Sie also Folgendes haben:
(counter.js):
var count = 1;
exports.increment = function() {
count++;
};
exports.getCount = function() {
return count;
};
... dann in Ihrer Anwendung (web.js oder wirklich jede andere .js-Datei):
var counting = require('./counter.js');
console.log(counting.getCount()); // 1
counting.increment();
console.log(counting.getCount()); // 2
Vereinfacht ausgedrückt können Sie sich erforderliche Dateien als Funktionen vorstellen, die ein einzelnes Objekt zurückgeben, und Sie können dem zurückgegebenen Objekt Eigenschaften (Zeichenfolgen, Zahlen, Arrays, Funktionen usw.) hinzufügen, indem Sie sie auf exports
setzen.
Manchmal möchten Sie, dass das von einem require()
-Aufruf zurückgegebene Objekt eine Funktion ist, die Sie aufrufen können, und nicht nur ein Objekt mit Eigenschaften. In diesem Fall müssen Sie auch module.exports
wie folgt einstellen:
(sayhello.js):
module.exports = exports = function() {
console.log("Hello World!");
};
(app.js):
var sayHello = require('./sayhello.js');
sayHello(); // "Hello World!"
Der Unterschied zwischen Exporten und module.exports wird in diese Antwort hier besser erklärt.
Beachten Sie, dass der NodeJS-Modulmechanismus auf CommonJS Modulen basiert, die in vielen anderen Implementierungen wie RequireJS, aber auch - unterstützt werden. SproutCore, CouchDB, Wakanda, OrientDB, ArangoDB, RingoJS, TeaJS, SilkJS, curl.js oder sogar Adobe Photoshop (via PSLib ). Die vollständige Liste der bekannten Implementierungen finden Sie hier .
Sofern Ihr Modul keine knotenspezifischen Funktionen oder Module verwendet, sollten Sie exports
anstelle von module.exports
verwenden, das nicht Teil des CommonJS-Standards ist und dann meistens nicht von unterstützt wird andere Implementierungen.
Eine weitere NodeJS-spezifische Funktion besteht darin, dass Sie exports
einen Verweis auf ein neues Objekt zuweisen, anstatt ihm nur Eigenschaften und Methoden hinzuzufügen, wie im letzten von Jed Watson in diesem Thread bereitgestellten Beispiel. Ich persönlich würde von dieser Praxis abraten, da dies die Zirkelreferenzunterstützung bricht des CommonJS-Modulmechanismus. Es wird dann nicht von allen Implementierungen unterstützt und Jed-Beispiel sollte dann so (oder ähnlich) geschrieben werden, um ein universelleres Modul bereitzustellen:
(sayhello.js):
exports.run = function() {
console.log("Hello World!");
}
(app.js):
var sayHello = require('./sayhello');
sayHello.run(); // "Hello World!"
Oder mit ES6-Funktionen
(sayhello.js):
Object.assign(exports, {
// Put all your public API here
sayhello() {
console.log("Hello World!");
}
});
(app.js):
const { sayHello } = require('./sayhello');
sayHello(); // "Hello World!"
PS: Es sieht so aus, als ob Appcelerator auch CommonJS-Module implementiert, jedoch ohne die Unterstützung für Zirkelverweise (siehe: Appcelerator- und CommonJS-Module (Caching und Zirkelverweise) )
Einige Dinge, die Sie beachten müssen, wenn Sie einem neuen Objekt einen Verweis auf exports
und/oder modules.exports
zuweisen:
exports
oder module.exports
angehängt wurden, gehen natürlich verloren, da das exportierte Objekt jetzt auf ein anderes neues Objekt verweistDies ist offensichtlich, aber wenn Sie eine exportierte Methode am Anfang eines vorhandenen Moduls hinzufügen, stellen Sie sicher, dass das native exportierte Objekt am Ende kein anderes Objekt referenziert
exports.method1 = function () {}; // exposed to the original exported object
exports.method2 = function () {}; // exposed to the original exported object
module.exports.method3 = function () {}; // exposed with method1 & method2
var otherAPI = {
// some properties and/or methods
}
exports = otherAPI; // replace the original API (works also with module.exports)
exports
oder module.exports
auf einen neuen Wert verweist, verweist er nicht mehr auf dasselbe Objektexports = function AConstructor() {}; // override the original exported object
exports.method2 = function () {}; // exposed to the new exported object
// method added to the original exports object which not exposed any more
module.exports.method3 = function () {};
exports
und module.exports
ändern, ist es schwer zu sagen, welche API verfügbar ist (es sieht aus wie module.exports
wins).// override the original exported object
module.exports = function AConstructor() {};
// try to override the original exported object
// but module.exports will be exposed instead
exports = function AnotherConstructor() {};
die Eigenschaft module.exports oder das Export-Objekt ermöglicht es einem Modul, auszuwählen, was mit der Anwendung gemeinsam genutzt werden soll
Ich habe ein Video zu module_export zur Verfügung hier
Wenn Sie Ihren Programmcode auf mehrere Dateien aufteilen, werden mit module.exports
Variablen und Funktionen für den Consumer eines Moduls veröffentlicht. Der Aufruf require()
in Ihrer Quelldatei wird durch den entsprechenden module.exports
ersetzt, der aus dem Modul geladen wurde.
Denken Sie beim Schreiben von Modulen daran
module.exports
-Objekt ist auch als exports
-Kurzform verfügbar. Wenn Sie jedoch eine einzige Funktion zurückgeben, verwenden Sie immer module.exports
.Entsprechend: "Module Teil 2 - Module schreiben" .
der Verweislink ist wie folgt:
exports = module.exports = function(){
//....
}
die Eigenschaften von exports
oder module.exports
, wie z. B. Funktionen oder Variablen, werden außerhalb angezeigt
es gibt etwas, das Sie mehr beachten müssen: Exportieren Sie nicht override
.
warum ?
da Exporte nur die Referenz von module.exports ausführen, können Sie die Eigenschaften zu den Exporten hinzufügen. Wenn Sie jedoch die Exporte überschreiben, wird der Referenzlink unterbrochen.
gutes Beispiel :
exports.name = 'william';
exports.getName = function(){
console.log(this.name);
}
schlechtes Beispiel :
exports = 'william';
exports = function(){
//...
}
Wenn Sie nur eine Funktion oder Variable anzeigen möchten, wie folgt:
// test.js
var name = 'william';
module.exports = function(){
console.log(name);
}
// index.js
var test = require('./test');
test();
dieses Modul hat nur eine Funktion verfügbar gemacht, und die Eigenschaft name ist privat für außen.
In node.js gibt es einige Standard- oder vorhandene Module, wenn Sie node.js wiehttp, sysusw. herunterladen und installieren.
Da sie sich bereits in node.js befinden, wenn wir diese Module verwenden wollen, machen wir grundsätzlich import modules, aber warum? weil sie bereits in node.js vorhanden sind. Importieren ist so, als würden Sie sie aus node.js nehmen und in Ihr Programm einfügen. Und dann mit ihnen.
WährendExportsgenau das Gegenteil ist, erstellen Sie das gewünschte Modul. Nehmen Sie das Modul Addition.js an und fügen Sie dieses Modul in die node.js ein, indem Sie es exportieren.
Bevor ich hier etwas schreibe, bedenke, dass module.exports.additionTwo dasselbe ist wie exports.additionTwo
Huh, das ist der Grund, den wir mögen
exports.additionTwo = function(x)
{return x+2;};
Sei vorsichtig mit dem Pfad
Nehmen wir an, Sie haben ein Modul add.js erstellt.
exports.additionTwo = function(x){
return x + 2;
};
Wenn Sie dies auf Ihrer NODE.JS-Eingabeaufforderung ausführen:
node
var run = require('addition.js');
Dies wird fehlerhaft zu sagen
Fehler: Modul add.js kann nicht gefunden werden
Dies liegt daran, dass der Prozess node.js die Addition.js nicht ausführen kann, da der Pfad nicht erwähnt wurde. Der Pfad kann also mit NODE_PATH gesetzt werden
set NODE_PATH = path/to/your/additon.js
Nun sollte dies fehlerfrei laufen !!
Eine weitere Sache ist, dass Sie die Datei „Additions.js“ auch ausführen können, indem Sie NODE_PATH nicht wieder auf den nodejs-Befehl Prompt setzen:
node
var run = require('./addition.js');
Da wir den Pfad hier angeben, indem wir sagen, er befindet sich im aktuellen Verzeichnis ./
, sollte dies ebenfalls erfolgreich ausgeführt werden.
Ein Modul kapselt zugehörigen Code in einer einzigen Codeeinheit. Beim Erstellen eines Moduls kann dies als Verschieben aller zugehörigen Funktionen in eine Datei interpretiert werden.
Angenommen, es gibt eine Datei Hello.js, die zwei Funktionen enthält
sayHelloInEnglish = function() {
return "Hello";
};
sayHelloInSpanish = function() {
return "Hola";
};
Wir schreiben eine Funktion nur, wenn der Code mehr als einen Aufruf enthält.
Angenommen, wir möchten die Nützlichkeit der Funktion auf eine andere Datei erhöhen, z. B. World.js. In diesem Fall wird beim Exportieren einer Datei ein Bild angezeigt, das mit module.exports abgerufen werden kann.
Sie können beide Funktionen einfach mit dem unten angegebenen Code exportieren
var anyVariable={
sayHelloInEnglish = function() {
return "Hello";
};
sayHelloInSpanish = function() {
return "Hola";
};
}
module.export=anyVariable;
Jetzt müssen Sie nur noch den Dateinamen in World.js eingeben, um diese Funktionen verwenden zu können
var world= require("./hello.js");
Die Absicht ist:
Modulare Programmierung ist eine Software-Entwurfstechnik, die .__ hervorhebt. Trennen der Funktionalität eines Programms in unabhängige, austauschbare Module, so dass jedes alles Notwendige enthält nur einen Aspekt der gewünschten Funktionalität ausführen.
Ich kann mir vorstellen, dass es schwierig wird, große Programme ohne modularen/wiederverwendbaren Code zu schreiben. In nodejs können modulare Programme erstellt werden, indem module.exports
definiert wird, was wir veröffentlichen und unser Programm mit require
zusammenstellen.
Versuchen Sie dieses Beispiel:
fileLog.js
function log(string) { require('fs').appendFileSync('log.txt',string); }
module.exports = log;
stdoutLog.js
function log(string) { console.log(string); }
module.exports = log;
program.js
const log = require('./stdoutLog.js')
log('hello world!');
ausführen
$ node program.js
hallo Welt!
Versuchen Sie jetzt, ./stdoutLog.js gegen ./fileLog.js zu tauschen.
Was ist der Zweck eines Modulsystems?
Es bewirkt die folgenden Dinge:
Durch die Verwendung von Modulen können bestimmte Teile des Codes leichter gefunden werden, wodurch der Code leichter zu warten ist.
Wie funktioniert es?
NodejS
verwendet das CommomJS-Modulsystem, das auf folgende Weise arbeitet:
module.export
-Syntax deklariert werdenrequire('file')
-Syntax deklariert werdentest1.js
const test2 = require('./test2'); // returns the module.exports object of a file
test2.Func1(); // logs func1
test2.Func2(); // logs func2
test2.js
module.exports.Func1 = () => {console.log('func1')};
exports.Func2 = () => {console.log('func2')};
require()
auf demselben Modul wird das Objekt aus dem Cache gezogen.require()
abgerufene Objekt zugreifen.