Was ist der Zweck von Node.js module.exports und wie verwenden Sie es?

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.exportsverwenden, 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:

1. Alle Eigenschaften/Methoden, die zuvor an das Original exports oder module.exports angehängt wurden, gehen natürlich verloren, da das exportierte Objekt jetzt auf ein anderes neues Objekt verweist

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

2. Falls einer von exports oder module.exports auf einen neuen Wert verweist, verweist er nicht mehr auf dasselbe Objekt

exports = 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 () {}; 

3. heikle Folge. Wenn Sie den Verweis auf 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

• Modulladungen werden zwischengespeichert, nur beim ersten Aufruf wird JavaScript ausgewertet.
• Es ist möglich, lokale Variablen und Funktionen innerhalb eines Moduls zu verwenden, nicht alles muss exportiert werden.
• Das 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.

Wikipedia

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:

1. Verhindert das Aufblähen unserer Dateien in wirklich große Größen. Dateien mit z. 5.000 Zeilen Code sind während der Entwicklung normalerweise sehr schwer zu bewältigen.
2. Erzwingt die Trennung von Bedenken. Durch die Aufteilung unseres Codes in mehrere Dateien können wir für jede Datei die entsprechenden Dateinamen verwenden. Auf diese Weise können wir leicht erkennen, was jedes Modul tut und wo es zu finden ist (vorausgesetzt, wir haben eine logische Verzeichnisstruktur erstellt, die immer noch in Ihrer Verantwortung liegt).

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:

1. Wenn eine Datei etwas exportieren möchte, muss sie mit der module.export-Syntax deklariert werden
2. Wenn eine Datei etwas importieren möchte, muss sie mit der require('file')-Syntax deklariert werden

Beispiel:

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

Weitere nützliche Dinge zu wissen:

1. Module werden zwischengespeichert . Wenn Sie dasselbe Modul in zwei verschiedenen Dateien laden, muss das Modul nur einmal geladen werden. Beim zweiten Aufruf einer require() auf demselben Modul wird das Objekt aus dem Cache gezogen.
2. Module werden in synchronem geladen. Dieses Verhalten ist erforderlich, wenn es asynchron war, konnten wir nicht sofort auf das von require() abgerufene Objekt zugreifen.