Erstellen eines Node.js-Moduls

Die Autorin wählte den Open Internet/Free Speech Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

Einführung

In Node.js ist ein Modul eine Sammlung von JavaScript-Funktionen und -Objekten, die von externen Anwendungen verwendet werden können. Die Beschreibung eines Code-Stücks als Modul bezieht sich weniger darauf, was der Code ist, als vielmehr darauf, was er tut – jede Node.js-Datei oder Sammlung von Dateien kann als Modul betrachtet werden, wenn ihre Funktionen und Daten für externe Programme gemacht werden.

Da Module Funktionseinheiten bereitstellen, die in vielen größeren Programmen wiederverwendet werden können, ermöglichen sie Ihnen die Erstellung lose gekoppelter Anwendungen, die mit der Komplexität skalieren, und öffnen Ihnen die Tür, um Ihren Code mit anderen Entwicklern zu teilen. Die Fähigkeit, Module zum Exportieren nützlicher Funktionen und Daten zu schreiben, ermöglicht es Ihnen, zur breiteren Node.js-Gemeinschaft beizutragen – tatsächlich wurden alle Pakete, die Sie auf npm verwenden, gebündelt und als Module freigegeben. Dies macht das Erstellen von Modulen zu einer unverzichtbaren Fertigkeit für einen Node.js-Entwickler.

In diesem Tutorial erstellen Sie ein Node.js-Modul, das vorschlägt, welche Farbe Web-Entwickler in ihren Designs verwenden sollten. Sie werden das Modul entwickeln, indem Sie die Farben als Array speichern und eine Funktion zum zufälligen Abrufen einer Farbe bereitstellen. Anschließend werden Sie verschiedene Möglichkeiten zum Importieren eines Moduls in eine Node.js-Anwendung ausführen.

Voraussetzungen

• Sie müssen Node.js und npm in Ihrer Entwicklungsumgebung installiert haben. Dieses Tutorial verwendet Version 10.17.0. Um dies unter MacOS oder Ubuntu 18.04 zu installieren, folgen Sie den Schritten in Installation von Node.js und Erstellen einer lokalen Entwicklungsumgebung auf MacOS oder dem Abschnitt Installation unter Verwendung eines PPA von Installation von Node.js auf Ubuntu 18.04. Durch die Installation von Node.js haben Sie auch npm installiert; dieses Tutorial verwendet Version 6.11.3.
• Sie sollten auch mit der Datei package.json vertraut sein, und Erfahrung mit npm-Befehlen wäre ebenfalls nützlich.  Um diese Erfahrung zu sammeln, folgen Sie der Anleitung Verwenden von Node.js-Modulen mit nmp und package.json, insbesondere dem Schritt 1 - Erstellen einer package.json-Datei.
• Hilfreich ist es auch, sich mit der REPL (Read-Evaluate-Print-Loop) von Node.js vertraut zu machen. Sie werden diese zum Testen Ihres Moduls verwenden. Wenn Sie weitere Informationen dazu benötigen, lesen Sie unseren Leitfaden Verwenden der Node.js REPL.

Schritt 1 – Erstellen eines Moduls

Dieser Schritt führt Sie durch die Erstellung Ihres ersten Node.js-Moduls. Ihr Modul wird eine Sammlung von Farben in einem Array und eine Funktion zum zufälligen Abrufen einer Farbe enthalten. Sie werden die in Node.js integrierte Eigenschaft exports verwenden, um die Funktion und das Array für externe Programme verfügbar zu machen.

Zuerst entscheiden Sie, welche Daten über Farben Sie in Ihrem Modul speichern werden. Jede Farbe wird ein Objekt sein, das eine Eigenschaft name enthält, die von Menschen leicht identifiziert werden kann, sowie eine Eigenschaft code, die eine Zeichenfolge ist, die einen HTML-Farbcode enthält. HTML-Farbcodes sind sechsstellige hexadezimale Zahlen, mit denen Sie die Farbe von Elementen auf einer Webseite ändern können. Der Artikel HTML-Farbcodes und -namen bietet Ihnen weitere Informationen über HTML-Farbcodes.

Dann entscheiden Sie, welche Farben Sie in Ihrem Modul unterstützen möchten. Ihr Modul wird ein Array namens allColors enthalten, das sechs Farben enthalten wird. Ihr Modul wird auch eine Funktion namens getRandomColor() enthalten, die zufällig eine Farbe aus Ihrem Array auswählt und zurückgibt.

Erstellen Sie in Ihrem Terminal einen neuen Ordner namens colors und wechseln Sie in diesen:

mkdir colors
cd colors

Initialisieren Sie npm, damit andere Programme dieses Modul später im Tutorial importieren können:

npm init -y

Sie haben das Flag -y verwendet, um die üblichen Eingabeaufforderungen zur Anpassung der package.json zu überspringen. Wenn dies ein Modul wäre, das Sie in npm veröffentlichen möchten, würden Sie alle diese Eingabeaufforderungen mit relevanten Daten beantworten, wie in Verwenden von Node.js-Modulen mit npm und package.json erklärt.

In diesem Fall wird Ihre Ausgabe sein:

Output
{
  "name": "colors",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Öffnen Sie nun einen Befehlszeilen-Texteditor wie nano und erstellen Sie eine neue Datei, die als Einstiegspunkt für Ihr Modul dient:

nano index.js

Ihr Modul wird einige Dinge tun. Zuerst definieren Sie eine Klasse Color. Ihre Klasse Color wird mit ihrem Namen und HTML-Code instanziert. Fügen Sie die folgenden Zeilen hinzu, um die Klasse zu erstellen:

class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

Nachdem Sie nun Ihre Datenstruktur für Color haben, fügen Sie einige Instanzen in Ihr Modul ein. Schreiben Sie das folgende hervorgehobene Array in Ihre Datei:

class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

Geben Sie anschließend eine Funktion ein, die zufällig ein Element aus dem Array allColors, das Sie soeben erstellt haben, auswählt:

class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

exports.getRandomColor = () => {
  return allColors[Math.floor(Math.random() * allColors.length)];
}

exports.allColors = allColors;

Das Schlüsselwort exports verweist auf ein globales Objekt, das in jedem Modul Node.js verfügbar ist. Alle im Objekt exports eines Moduls gespeicherten Funktionen und Objekte werden beim Import von anderen Node.js-Modulen verfügbar gemacht. Die Funktion getRandomColor() wurde zum Beispiel direkt auf dem Objekt exports erstellt. Dann haben Sie dem Objekt exports eine Eigenschaft allColors hinzugefügt, die auf das zuvor im Skript erstellte lokale konstante Array allColors verweist.

Wenn andere Module dieses Modul importieren, werden sowohl allColors als auch getRandomColor() verfügbar sein.

Speichern und schließen Sie die Datei.

Bisher haben Sie ein Modul erstellt, das ein Array von Farben und eine Funktion enthält, die eine Farbe nach dem Zufallsprinzip zurückgibt. Sie haben das Array und die Funktion auch exportiert, damit externe Programme sie verwenden können. Im nächsten Schritt werden Sie Ihr Modul in anderen Anwendungen verwenden, um die Auswirkungen von export zu demonstrieren.

Schritt 2 – Testen Ihres Moduls mit der REPL

Bevor Sie eine vollständige Anwendung erstellen, nehmen Sie sich einen Moment Zeit, um die Funktionsfähigkeit Ihres Moduls zu bestätigen. In diesem Schritt werden Sie das REPL zum Laden des Moduls colors verwenden. Während Sie sich in REPL befinden, werden Sie die Funktion getRandomColor() aufrufen, um zu sehen, ob sie sich wie von Ihnen erwartet verhält.

Starten Sie die Node.js REPL in dem gleichen Ordner wie die Datei index.js:

node

Wenn die REPL gestartet ist, sehen Sie die Eingabeaufforderung >. Das bedeutet, dass Sie JavaScript-Code eingeben können, der sofort ausgewertet wird. Wenn Sie mehr darüber lesen möchten, folgen Sie unserem Leitfaden über das Verwenden der REPL.

Geben Sie zunächst Folgendes ein:

colors = require('./index');

In diesem Befehl lädt require() das Modul colors an seinem Eintrittspunkt. Wenn Sie die Eingabetaste drücken, erhalten Sie:

Output
{
  getRandomColor: [Function],
  allColors: [
    Color { name: 'brightred', code: '#E74C3C' },
    Color { name: 'soothingpurple', code: '#9B59B6' },
    Color { name: 'skyblue', code: '#5DADE2' },
    Color { name: 'leafygreen', code: '#48C9B0' },
    Color { name: 'sunkissedyellow', code: '#F4D03F' },
    Color { name: 'groovygray', code: '#D7DBDD' }
  ]
}

Die REPL zeigt uns den Wert von colors, was alle Funktionen und Objekte sind, die aus der Datei index.js importiert wurden. Bei der Verwendung des Schlüsselworts require gibt Node.js den Inhalt innerhalb des Objekts exports eines Moduls zurück.

Erinnern Sie sich, dass Sie getRandomColor() und allColors zu exports in dem Modul colors hinzugefügt haben. Aus diesem Grund sehen Sie sie beide, wenn sie in die REPL importiert werden.

Testen Sie an der Eingabeaufforderung die Funktion getRandomColor():

colors.getRandomColor();

Ihnen wird eine zufällige Farbe ausgegeben:

Output
Color { name: 'groovygray', code: '#D7DBDD' }

Da der Index zufällig ist, kann Ihre Ausgabe variieren. Nachdem Sie nun bestätigt haben, dass das Modul colors funktioniert, beenden Sie die Node.js REPL:

.exit

Dadurch kehren Sie zu Ihrer Terminal-Befehlszeile zurück.

Sie haben gerade mit der REPL bestätigt, dass Ihr Modul wie erwartet funktioniert. Als Nächstes werden Sie dieselben Konzepte anwenden und Ihr Modul in eine Anwendung laden, wie Sie es in einem echten Projekt tun würden.

Schritt 3 – Speichern Ihres lokalen Moduls als Abhängigkeit

Beim Testen Ihres Moduls in der REPL haben Sie sie mit einem relativen Pfad importiert. Das bedeutet, dass Sie den Speicherort der Datei index.js in Bezug auf das Arbeitsverzeichnis verwendet haben, um ihren Inhalt zu erhalten. Das funktioniert zwar, jedoch ist es in der Regel eine bessere Programmiererfahrung, Module anhand ihrer Namen zu importieren, damit der Import bei der Änderung des Kontexts nicht unterbrochen wird. In diesem Schritt werden Sie das Modul colors mit der Funktion des lokalen Moduls install von npm installieren.

Richten Sie ein neues Node.js-Modul außerhalb des Ordners colors ein. Gehen Sie zunächst in das vorherige Verzeichnis und erstellen Sie einen neuen Ordner:

cd ..
mkdir really-large-application

Gehen Sie nun in Ihr neues Projekt:

cd really-large-application

Initialisieren Sie Ihren Ordner, wie bei dem Modul colors, mit npm:

npm init -y

Die folgende package.json wird generiert:

Output
{
  "name": "really-large-application",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Installieren Sie nun Ihr Modul colors und verwenden Sie das Flag --save, damit es in Ihrer Datei package.json aufgezeichnet wird:

npm install --save ../colors

Sie haben soeben Ihr Modul colors im neuen Projekt installiert. Öffnen Sie die Datei package.json, um die neue lokale Abhängigkeit zu sehen:

nano package.json

Sie werden feststellen, dass die folgenden hervorgehobenen Zeilen hinzugefügt wurden:

{
  "name": "really-large-application",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "colors": "file:../colors"
  }
}

Beenden Sie die Datei.

Das Modul colors wurde in Ihr Verzeichnis node_modules kopiert. Verifizieren Sie dies mit dem folgenden Befehl:

ls node_modules

Dadurch erhalten Sie folgenden Output:

Output
colors

Verwenden Sie Ihr installiertes lokales Modul in diesem neuen Programm. Öffnen Sie erneut Ihren Texteditor und erstellen Sie eine weitere JavaScript-Datei:

nano index.js

Ihr Programm importiert zunächst das Modul colors. Dann wählt es unter Verwendung der von dem Modul bereitgestellten Funktion getRandomColor() eine Farbe nach dem Zufallsprinzip aus. Schließlich wird es eine Meldung an die Konsole ausgeben, die dem Benutzer mitteilt, welche Farbe zu verwenden ist.

Geben Sie den folgenden Code in index.js ein:

const colors = require('colors');

const chosenColor = colors.getRandomColor();
console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);

Speichern und schließen Sie diese Datei.

Ihre Anwendung teilt dem Benutzer nun eine zufällige Farboption für eine Website-Komponente mit.

Führen Sie dieses Skript aus mit:

node index.js

Ihre Ausgabe wird der folgenden ähneln:

Output
You should use leafygreen on your website. It's HTML code is #48C9B0

Sie haben nun das Modul colors erfolgreich installiert und können es wie jedes andere in Ihrem Projekt verwendete npm-Paket verwalten. Wenn Sie Ihrem lokalen Modul colors jedoch mehr Farben und Funktionen hinzugefügt haben, müssten Sie npm update in Ihren Anwendungen ausführen, um die neuen Optionen verwenden zu können. Im nächsten Schritt werden Sie das lokale Modul colors auf eine andere Art und Weise verwenden und automatisch Aktualisierungen erhalten, wenn sich der Modulcode ändert.

Schritt 4 – Verknüpfen eines lokalen Moduls

Wenn sich Ihr lokales Modul in intensiver Entwicklung befindet, kann die kontinuierliche Aktualisierung von Paketen mühsam sein. Eine Alternative wäre es, die Module zu verknüpfen. Die Verknüpfung eines Moduls stellt sicher, dass alle Aktualisierungen des Moduls sofort in den Anwendungen, die es verwenden, berücksichtigt werden.

In diesem Schritt werden Sie das Modul colors mit Ihrer Anwendung verknüpfen. Sie werden das Modul colors auch modifizieren und bestätigen, dass seine letzten Änderungen in der Anwendung funktionieren, ohne dass eine Neuinstallation oder eine Aktualisierung erforderlich ist.

Deinstallieren Sie zunächst Ihr lokales Modul:

npm un colors

npm verknüpft Module durch die Verwendung von symbolischen Verknüpfungen (oder Symlinks), die Verweise sind, die auf Dateien oder Verzeichnisse auf Ihrem Computer verweisen. Die Verknüpfung eines Moduls erfolgt in zwei Schritten:

1. Erstellen einer globalen Verknüpfung mit dem Modul. npm erstellt einen Symlink zwischen Ihrem globalen Verzeichnis node_modules und dem Verzeichnis Ihres Moduls. Das globale Verzeichnis node_modules ist der Ort, an dem alle Ihre systemweiten npm-Pakete installiert werden (jedes Paket, das Sie mit dem Flag -g installieren).
2. Erstellen einer lokalen Verknüpfung. npm erstellt einen Symlink zwischen Ihrem lokalen Projekt, das das Modul verwendet, und der globalen Verknüpfung des Moduls.

Erstellen Sie zunächst die globale Verknüpfung, indem Sie zu dem Ordner colors zurückkehren und den Befehl link verwenden:

cd ../colors
sudo npm link

Nach dem Abschluss wird Ihre Shell Folgendes ausgeben:

Output
/usr/local/lib/node_modules/colors -> /home/sammy/colors

Sie haben soeben in Ihrem Ordner node_modules einen Symlink auf Ihr Verzeichnis colors erstellt.

Kehren Sie zu dem Ordner really-large-application zurück und verknüpfen Sie das Paket:

cd ../really-large-application
sudo npm link colors

Sie werden eine Ausgabe sehen, die etwa folgendermaßen aussieht:

Output
/home/sammy/really-large-application/node_modules/colors -> /usr/local/lib/node_modules/colors -> /home/sammy/colors

Wie die Ausgabe zeigt, haben Sie soeben einen Symlink vom lokalen Verzeichnis node_modules Ihrer really-large-application zu dem Symlink colors in ihrem globalen node_modules erstellt, der auf das tatsächliche Verzeichnis mit dem Modul colors verweist.

Der Verknüpfungsvorgang ist abgeschlossen. Führen Sie Ihre Datei aus, um sicherzustellen, dass sie immer noch funktioniert:

node index.js

Ihre Ausgabe wird der folgenden ähneln:

Output
You should use sunkissedyellow on your website. It's HTML code is #F4D03F

Ihre Programmfunktionalität ist intakt. Testen Sie als Nächstes, dass Aktualisierungen sofort angewendet werden. Öffnen Sie in Ihrem Texteditor erneut die Datei index.js im Modul colors:

cd ../colors
nano index.js

Fügen Sie nun eine Funktion hinzu, die den besten vorhandenen Blauton auswählt. Sie benötigt keine Argumente und gibt immer das dritte Element des Arrays allColors zurück. Fügen Sie diese Zeilen dem Ende der Datei hinzu:

class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

exports.getRandomColor = () => {
        return allColors[Math.floor(Math.random() * allColors.length)];
        }

exports.allColors = allColors;

exports.getBlue = () => {
  return allColors[2];
}

Speichern und schließen Sie die Datei und öffnen Sie dann erneut die Datei index.js im Ordner really-large-application:

cd ../really-large-application
nano index.js

Rufen Sie die neu erstellte Funktion getBlue() auf und drucken Sie einen Satz mit den Eigenschaften der Farbe aus. Fügen Sie diese Anweisungen am Ende der Datei hinzu:

const colors = require('colors');

const chosenColor = colors.getRandomColor();
console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);

const favoriteColor = colors.getBlue();
console.log(`My favorite color is ${favoriteColor.name}/${favoriteColor.code}, btw`);

Speichern und schließen Sie die Datei.

Der Code verwendet nun die neu erstellte Funktion getBlue(). Führen Sie die Datei wie zuvor aus:

node index.js

Sie erhalten eine Ausgabe wie:

Output
You should use brightred on your website. It's HTML code is #E74C3C
My favorite color is skyblue/#5DADE2, btw

Ihr Skript konnte die neueste Funktion in Ihrem Modul colors verwenden, ohne npm update ausführen zu müssen. Dadurch wird es einfacher, Änderungen an dieser Anwendung in der Entwicklung vorzunehmen.

Wenn Sie größere und komplexere Anwendungen schreiben, denken Sie darüber nach, wie verwandter Code in Module gruppiert werden kann und wie diese Module eingerichtet werden sollen. Wenn Ihr Modul nur von einem Programm verwendet werden soll, kann es innerhalb desselben Projekts bleiben und durch einen relativen Pfad referenziert werden. Wenn Ihr Modul später separat gemeinsam genutzt werden soll oder an ganz anderer Stelle existiert als das Projekt, an dem Sie gerade arbeiten, könnte eine Installation oder Verknüpfung sinnvoller sein. Module in aktiver Entwicklung profitieren auch von der automatischen Aktualisierung der Verknüpfung. Wenn sich das Modul nicht in der aktiven Entwicklung befindet, kann die Verwendung von npm install die einfachere Option sein.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, dass ein Node.js-Modul eine JavaScript-Datei mit Funktionen und Objekten ist, die von anderen Programmen verwendet werden können. Anschließend haben Sie ein Modul erstellt und Ihre Funktionen und Objekte an das lokale Objekt exports angehängt, um sie externen Programmen zur Verfügung zu stellen. Schließlich haben Sie dieses Modul in ein Programm importiert, um zu demonstrieren, wie Module zu größeren Anwendungen zusammengefügt werden.

Nachdem Sie nun wissen, wie Sie Module erstellen, denken Sie über die Art des Programms nach, das Sie schreiben möchten und zerlegen Sie es in verschiedene Komponenten, wobei Sie jeden eindeutigen Satz von Aktivitäten und Daten in ihren eigenen Modulen aufbewahren. Je mehr Übung Sie beim Schreiben von Modulen erhalten, desto besser wird Ihre Fähigkeit, qualitativ hochwertige Node.js-Programme zu schreiben. Ein Beispiel für eine Node.js-Anwendung, die Module verwendet, finden Sie in unserem Tutorial Einrichten einer Node.js-Anwendung für die Produktion unter Ubuntu 18.04.