Detaillierte Erläuterung des Node.js-Modulsloading_node.js

JavaScript ist eine der am häufigsten verwendeten Programmiersprachen der Welt. Es ist die universelle Sprache der Webwelt und wird von allen Browsern verwendet. Die Geburt von JavaScript lässt sich bis in die Netscape-Ära zurückverfolgen. Sein Kerninhalt wurde hastig entwickelt, um mit Microsoft zu konkurrieren und am damaligen heftigen Browserkrieg teilzunehmen. Aufgrund der vorzeitigen Veröffentlichung führte es zwangsläufig zu einigen nicht so guten Funktionen.

Trotz seiner kurzen Entwicklungszeit verfügt JavaScript immer noch über viele leistungsstarke Funktionen, außer dass jedes Skript einen globalen Namespace teilt.

Sobald eine Webseite JavaScript-Code lädt, wird dieser in den globalen Namespace eingefügt und teilt sich den gleichen Adressraum mit allen anderen geladenen Skripten. Dies führt zu vielen Sicherheitsproblemen, Konflikten und einigen häufigen Fehlern schwer zu verfolgen und schwer zu lösen.

Aber zum Glück hat Node einige Spezifikationen für serverseitiges JavaScript festgelegt und auch den CommonJS-Modulstandard implementiert. In diesem Standard hat jedes Modul seinen eigenen Kontext und unterscheidet sich von anderen Modulen. Dies bedeutet, dass Module den globalen Bereich nicht verschmutzen, da es keinen globalen Bereich gibt und Module sich nicht gegenseitig stören.

In diesem Kapitel lernen wir verschiedene Module kennen und erfahren, wie man sie lädt.

Die Aufteilung Ihres Codes in eine Reihe klar definierter Module kann Ihnen helfen, die Kontrolle über Ihre Anwendung zu übernehmen. Im Folgenden erfahren Sie, wie Sie Ihre eigenen Module erstellen und verwenden.

Erfahren Sie, wie Node Module lädt

In Node können Module über den Dateipfad oder den Modulnamen referenziert werden. Wenn ein Nicht-Kernmodul über den Namen referenziert wird, ordnet Node den Modulnamen schließlich dem entsprechenden Moduldateipfad zu. Die Kernmodule, die Kernfunktionen enthalten, werden beim Start von Node vorinstalliert.

Zu den Nicht-Kernmodulen gehören Module von Drittanbietern, die mit NPM (Node Package Manager) installiert wurden, sowie lokale Module, die von Ihnen oder Ihren Kollegen erstellt wurden.

Jedes vom aktuellen Skript importierte Modul stellt Programmierern eine Reihe öffentlicher APIs zur Verfügung. Bevor Sie das Modul verwenden, müssen Sie es mit der Funktion „require“ importieren, etwa so:

Code kopieren Der Code lautet wie folgt:

var module = require(‘module_name’)

Der obige Code importiert ein Modul mit dem Namen module_name, bei dem es sich um ein Kernmodul oder ein mit NPM installiertes Modul handeln kann. Die Funktion „require“ gibt ein Objekt zurück, das alle öffentlichen APIs des Moduls enthält. Abhängig vom Modul kann das zurückgegebene Objekt ein beliebiger JavaScript-Wert, eine Funktion oder ein Objekt sein, das eine Reihe von Eigenschaften enthält (eine Funktion, ein Array oder ein beliebiges JavaScript-Objekt).

Modul exportieren

Das CommonJS-Modulsystem ist die einzige Möglichkeit, Objekte und Funktionen zwischen Dateien unter Node zu teilen. Bei einem sehr komplexen Programm sollten Sie einige Klassen, Objekte oder Funktionen in eine Reihe klar definierter wiederverwendbarer Module umstrukturieren. Dem Benutzer des Moduls stellt das Modul nur den von Ihnen angegebenen Code zur Verfügung.

Im folgenden Beispiel erfahren Sie, dass es eine Eins-zu-eins-Entsprechung zwischen Dateien und Modulen in Node gibt. Wir haben eine Datei namens „circle.js“ erstellt, die nur den Circle-Konstruktor exportiert.

Code kopieren Der Code lautet wie folgt:

Funktion Circle(x, y, r) {

Funktion r_squared() {

return Math.pow(r, 2);

}

Funktionsbereich() {

return Math.PI * r_squared();

}

return {area: area};

}

module.exports = Circle;

Die wichtigste Zeile im Code ist die letzte Zeile, die definiert, was das Modul exportiert. module ist eine spezielle Variable, die das aktuelle Modul selbst darstellt, und module.exports ist das vom Modul exportierte Objekt. In diesem Beispiel haben wir den Konstruktor von Circle exportiert, damit Modulbenutzer dieses Modul erstellen können Kreisinstanzen.

Sie können auch einige komplexe Objekte exportieren, die als leeres Objekt initialisiert werden. Sie können jeden Inhalt, den Sie der Außenwelt zugänglich machen möchten, als Attribute des module.exports-Objekts exportieren. Sie entwerfen beispielsweise ein Modul, das eine Reihe von Funktionen verfügbar macht:

Code kopieren Der Code lautet wie folgt:

Funktion printA() {

console.log('A');

}

Funktion printB() {

console.log('B');

}

Funktion printC() {

console.log('C');

}

module.exports.printA = printA;

module.exports.printB = printB;

module.exports.pi = Math.PI;

Dieses Modul exportiert zwei Funktionen (printA und printB) und eine Zahl (pi). Der aufrufende Code sieht so aus:

Code kopieren Der Code lautet wie folgt:

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

myModule2.printA(); // ->

myModule2.printB(); // ->

console.log(myModule2.pi); // ->

Modul laden

Wie bereits erwähnt, können Sie die Funktion „require“ zum Laden von Modulen verwenden. Sie müssen sich keine Sorgen machen, dass der Aufruf von „require“ im Code Auswirkungen auf den globalen Namespace hat, da es in Node kein Konzept für einen globalen Namespace gibt. Wenn das Modul vorhanden ist und keine Syntax- oder Initialisierungsfehler vorliegen, gibt die Anforderungsfunktion das Modulobjekt zurück und Sie können dieses Objekt einer beliebigen lokalen Variablen zuweisen.

Es gibt verschiedene Arten von Modulen, die grob in Kernmodule, lokale Module und über NPM installierte Module von Drittanbietern unterteilt werden können. Je nach Modultyp gibt es mehrere Möglichkeiten, auf das Modul zu verweisen dieses Wissen.

Kernmodul laden

Der Knoten verfügt über einige Module, die in Binärdateien kompiliert sind, die als Kernmodule bezeichnet werden. Auf sie kann nicht über Pfade verwiesen werden, sondern nur über Modulnamen. Das Kernmodul hat die höchste Ladepriorität. Auch wenn ein Drittanbietermodul mit demselben Namen vorhanden ist, wird das Kernmodul zuerst geladen.

Wenn Sie beispielsweise das http-Kernmodul laden und verwenden möchten, können Sie Folgendes tun:

Code kopieren Der Code lautet wie folgt:         var http = require('http');

Dadurch wird ein http-Modulobjekt zurückgegeben, das die in der Node-API-Dokumentation definierte HTTP-Modul-API enthält.

Dateimodul laden

Sie können Module auch über absolute Pfade aus dem Dateisystem laden:

Code kopieren Der Code lautet wie folgt: var myModule = require('/home/pedro/my_modules/my_module');

Sie können auch einen relativen Pfad basierend auf der aktuellen Datei verwenden:

Code kopieren Der Code lautet wie folgt: var myModule = require('../my_modules/my_module');

var myModule2 = require('./lib/my_module_2');

Achten Sie auf den obigen Code. Wenn Node die Datei nicht finden kann, wird die Suche erneut versucht, indem das Suffix js nach dem Dateinamen hinzugefügt wird Zusätzlich zu js wird auch nach json und node gesucht. Weitere Informationen finden Sie in der offiziellen Website-Dokumentation. Wenn sich daher im aktuellen Verzeichnis eine Datei mit dem Namen my_module.js befindet, gibt es die folgenden zwei Lademethoden :

Code kopieren Der Code lautet wie folgt: var myModule = require('./my_module');

var myModule = require('./my_module.js');

Verzeichnismodul laden

Sie können zum Laden von Modulen auch den Pfad zu einem Verzeichnis verwenden:

Code kopieren Der Code lautet wie folgt: var myModule = require('./myModuleDir');

Knoten geht davon aus, dass es sich bei diesem Verzeichnis um ein Modulpaket handelt, und versucht, in diesem Verzeichnis nach der Paketdefinitionsdatei package.json zu suchen.

Wenn es nicht gefunden wird, geht Node davon aus, dass der Einstiegspunkt des Pakets die Datei index.js ist (Anmerkung des Übersetzers: Zusätzlich zu index.js wird auch nach index.node gesucht. Die Datei .node ist die Binärdatei Erweiterungspaket von Node. Weitere Informationen finden Sie in der offiziellen Dokumentation. Am Beispiel des obigen Codes versucht Node, die Datei ./myModuleDir/index.js zu finden.

Wenn im Gegenteil die Datei package.json gefunden wird, versucht Node, sie zu analysieren, nach dem Hauptattribut in der Paketdefinition zu suchen und dann den Wert des Hauptattributs als relativen Pfad des Einstiegspunkts zu verwenden . In diesem Beispiel ist package.json wie folgt definiert:

Code kopieren Der Code lautet wie folgt:

                                                       {

"name" : "myModule",

"main" : "./lib/myModule.js"

            }

Knoten wird versuchen, die Datei ./myModuleDir/lib/myModule.js zu laden

Laden aus dem Verzeichnis node_modules

Wenn der Parameter der Anforderungsfunktion kein relativer Pfad oder Kernmodulname ist, sucht Node im Unterverzeichnis node_modules des aktuellen Verzeichnisses. Im folgenden Code versucht Node beispielsweise, die Datei zu finden./ node_modules/myModule.js:

Code kopieren Der Code lautet wie folgt:

var myModule = require('myModule.js');

Wenn es nicht gefunden wird, sucht Node weiter im Ordner „node_modules“ des Verzeichnisses der oberen Ebene. Wenn es noch nicht gefunden wird, wird die Suche im Verzeichnis der oberen Ebene fortgesetzt, bis das entsprechende Modul gefunden wird erreicht ist.

Sie können diese Funktion verwenden, um die Inhalte oder Module des Verzeichnisses „node_modules“ zu verwalten. Überlassen Sie die Modulverwaltungsaufgaben jedoch am besten NPM (siehe Kapitel 1). Das lokale Verzeichnis „node_modules“ ist der Standardspeicherort für die Installation von Modulen durch NPM . Dieser Designknoten und NPM sind miteinander verknüpft. Normalerweise müssen Sie sich als Entwickler nicht allzu sehr um diese Funktion kümmern, Sie können NPM einfach zum Installieren, Aktualisieren und Löschen von Paketen verwenden und es verwaltet das Verzeichnis node_modules für Sie

Cache-Modul

Module werden nach dem ersten erfolgreichen Laden zwischengespeichert, d. h. wenn der Modulname in denselben Dateipfad aufgelöst wird, gibt jeder Aufruf von require('myModule') genau dasselbe Modul zurück.

Zum Beispiel gibt es ein Modul namens my_module.js, das den folgenden Inhalt enthält:

Code kopieren Der Code lautet wie folgt:

console.log('module my_module initializing...');

module.exports = function() {

console.log('Hi!');

};

console.log('my_module initialized.');

Dann laden Sie das Modul mit folgendem Code:

Code kopieren Der Code lautet wie folgt:

var myModuleInstance1 = require('./my_module');

Es erzeugt die folgende Ausgabe:

Code kopieren Der Code lautet wie folgt:

Modul my_module wird initialisiert...

mein_modul initialisiert

Wenn wir es zweimal importieren:

Code kopieren Der Code lautet wie folgt:

var myModuleInstance1 = require('./my_module');

var myModuleInstance2 = require('./my_module');

Die Ausgabe lautet immer noch:

Code kopieren Der Code lautet wie folgt:

Modul my_module wird initialisiert...

mein_modul initialisiert

Mit anderen Worten: Der Initialisierungscode des Moduls wird nur einmal ausgeführt. Wenn Sie Ihre eigenen Module erstellen, achten Sie besonders auf diese Funktion, wenn der Initialisierungscode des Moduls Code enthält, der Nebenwirkungen hervorrufen kann.

Zusammenfassung

Node hebt den standardmäßigen globalen Geltungsbereich von JavaScript auf und übernimmt das CommonJS-Modulsystem, damit Sie Ihren Code besser organisieren und viele Sicherheitsprobleme und Fehler vermeiden können. Sie können die Funktion „require“ verwenden, um Kernmodule und Module von Drittanbietern zu laden oder Ihre eigenen Module aus Dateien und Verzeichnissen zu laden

Sie können zum Laden von Nicht-Kernmodulen auch relative Pfade oder absolute Pfade verwenden. Wenn Sie das Modul im Verzeichnis node_modules ablegen oder mit NPM installierte Module, können Sie zum Laden auch direkt den Modulnamen verwenden.

Anmerkung des Übersetzers:

Es wird den Lesern empfohlen, das Modulkapitel des offiziellen Dokuments zu lesen. Ich persönlich bin der Meinung, dass es klarer und klarer ist als der Autor. Es enthält auch ein sehr repräsentatives Beispiel, das für das Verständnis des Knotenmodulladens sehr hilfreich ist. Lassen Sie uns dieses Beispiel zitieren:

Code kopieren Der Code lautet wie folgt:

Verwenden Sie require(X), um das Modul unter Pfad Y zu laden

1. Wenn X ein Kernmodul ist,

a. Laden Sie das Kernmodul und geben Sie es zurück

b. Ende

2. Wenn X mit „./“ oder „/“ oder „../“ beginnt

a. LOAD_AS_FILE(Y X)

b. LOAD_AS_DIRECTORY(Y X)

3. LOAD_NODE_MODULES(X, Verzeichnisname(Y))

4. Ausnahme auslösen: „nicht gefunden“

LOAD_AS_FILE(X)

1. Wenn X eine Datei ist, laden Sie X als JavaScript-Skript und beenden Sie es nach dem Laden

2. Wenn X.js eine Datei ist, laden Sie X.js als JavaScript-Skript und beenden Sie es nach dem Laden

3. Wenn X.node eine Datei ist, laden Sie X.node als Node-Binär-Plug-in und beenden Sie den Vorgang, nachdem der Ladevorgang abgeschlossen ist

LOAD_AS_DIRECTORY(X)

1. Wenn die Datei X/package.json vorhanden ist,

a. Analysieren Sie X/package.json und suchen Sie das Feld „main“.

b. Ein weiteres M = X (der Wert des Hauptfelds)

c. LOAD_AS_FILE(M)

2. Wenn die Datei X/index.js vorhanden ist, laden Sie X/index.js als JavaScript-Skript und beenden Sie nach dem Laden

3. Wenn die Datei X/index.node vorhanden ist, laden Sie X/index.node als Node-Binär-Plug-in und beenden Sie den Vorgang, nachdem der Ladevorgang abgeschlossen ist

LOAD_NODE_MODULES(X, START)

1. Auch DIRS=NODE_MODULES_PATHS(START)

2. Führen Sie die folgenden Vorgänge für jedes Verzeichnis DIR unter DIRS aus:

a. LOAD_AS_FILE(DIR/X)

b. LOAD_AS_DIRECTORY(DIR/X)

NODE_MODULES_PATHS(START)

1. Ein weiterer PARTS = Pfadaufteilung (START)

2. Ein weiterer ROOT = Index der ersten Instanz von „node_modules“ in PARTS, oder 0

3. I = Anzahl der TEILE - 1

4. Ein weiteres DIRS = []

5. während ich >

a. Wenn PARTS[I] = „node_modules“, fahren Sie mit der nachfolgenden Operation fort, andernfalls kommt es beim nächsten Mal zu einer Schleife

c. DIR = path join(PARTS[0 .. I] "node_modules")

b. DIRS = DIRS DIR

c. Ein weiteres I = I - 1

6. Zurück zu DIRS