Node.js-Einführung: Die JavaScript-Laufzeitumgebung im Überblick

Im Folgenden veranschaulichen wir den Einsatz von Node.js am Beispiel einer lokalen Windows-Installation. Wie Sie Node.js auf Ihrem Windows-Rechner installieren, zeigen wir Ihnen in drei einfachen Schritten.

Ihre lokale Node.js-Installation ist nun einsatzbereit.

Sie befinden sich nun im interaktiven Command-Prompt von Node.js. Um zu überprüfen, ob Node.js korrekt installiert wurde und einwandfrei funktioniert, empfehlen wir die Funktion console.log(). Diese nimmt Werte entgegen und gibt sie auf dem Terminal aus. Testen Sie dies beispielsweise mit einem einfachen „Hello World!“-Skript.

Die Terminalausgabe zeigt, dass Node.js korrekt installiert wurde und in der Lage ist, JavaScript-Code interaktiv auszuführen. Alternativ lässt sich mit console.log() z. B. das Ergebnis einer Rechenaufgabe ins Terminal schreiben:

Möchten Sie sich detaillierte Informationen über die installierte Node.js-Version und deren Module ausgeben lassen, kommt folgender Ausdruck (expression) zum Einsatz:

Möchten Sie Node.js beenden und zurück in die Windows-Eingabeaufforderung wechseln, nutzen Sie die Tastenkombination [STRG] + [C]. Es sind zwei Anschläge notwendig. Dies verhindert, dass Sie den interaktiven Command-Prompt unbeabsichtigt verlassen.

Beachten Sie: Kommt – wie oben beschrieben – das Installations-Set-up zum Einsatz, kann pro System lediglich eine Version der JavaScript-Laufzeitumgebung installiert werden. Bei der Installation einer neuen Node.js-Version wird die ältere Version überschrieben. Möchten Sie mehr als eine Version von Node.js gleichzeitig betreiben, benötigen Sie einen Versionsmanager wie nvm (Node Version Manager).

Auf Basis der Laufzeitumgebung V8 schreiben Sie mit Node.js effiziente Webserver und andere Netzwerkanwendungen in der beliebten Skriptsprache JavaScript. Dabei überzeugt Node.js mit einem bewusst kompakt gehaltenen Aufbau, bei dem lediglich Kernfunktionalitäten wie die Interaktion mit dem Betriebssystem, die Netzwerkkommunikation oder Verschlüsselungsmechanismen als Basismodule in die Laufzeitumgebung integriert wurden. Alle weiteren Funktionalitäten werden als Erweiterungsmodule eingebunden. Anwender können dabei auf ein umfangreiches Sortiment von Drittanbietermodulen zurückgreifen oder eigene Module programmieren.

Um ein beliebiges Modul in eine Node.js-Anwendung zu laden, benötigen Sie lediglich die Funktion require(). Diese erwartet einen String, der als Parameter angibt, welches Modul geladen werden soll. In der Regel handelt es sich um den Namen des Moduls. Kommt require() in Kombination mit einem Modulnamen zum Einsatz, durchsucht Node.js diverse Verzeichnisse nach Modulen, die als Basismodule Teil von Node.js sind oder die mit npm projektspezifisch (lokal) oder projektübergreifend (global) installiert wurden. Diese Module werden ohne Pfadangabe gefunden. Nicht durchsucht wird das aktuelle Arbeitsverzeichnis. Möchten Sie ein selbstgeschriebenes Modul aus Ihrem aktuellen Projektverzeichnis laden, wird eine relative Pfadangabe mit ./ benötigt.

Folgende Beispiele zeigen beide Grundschemata, nach denen Module in Node.js-Anwendungen geladen werden:

In diesem Node.js-Tutorial zeigen wir Ihnen anhand von Beispielen, wie Sie Basismodule verwenden, Drittanbietermodule einbinden und eigene Node.js-Module erstellen.

Das Modul os bietet diverse Funktionen, mit denen sich betriebssystembezogene Informationen ausgeben lassen. Möchte ein Anwender beispielsweise die Menge an freiem Systemspeicher in Byte erfahren, käme folgender Code zum Einsatz:

Wie die Ausgabe im Terminal zeigt, stehen auf unserem Testsystem aktuell 3,1 Gigabyte Systemspeicher zur Verfügung.

Mit anderen Funktionen des os-Moduls wie os.networkInterfaces() oder os.hostname() lässt sich eine Liste mit Netzwerkschnittstellen ausgeben oder der Hostname ermitteln.

Die nachstehende Tabelle enthält eine Auswahl der wichtigsten Basismodule der JavaScript-Laufzeitumgebungen inklusive Beschreibung.

Weitere Informationen zu diesen und anderen Basismodulen von Node.js finden Sie in der offiziellen Dokumentation des Software-Projekts.

Die Nachinstallation von Programmmodulen erfolgt bei Node.js über den integrierten Paket-Manager npm. Dieser erlaubt Node.js-Nutzern den Zugriff auf die npm-Registry, ein communitygestütztes Online-Archiv für Node.js-Module. Erweiterungsmodule müssen somit nicht manuell von externen Seiten heruntergeladen und in ein entsprechendes Verzeichnis kopiert werden. Der Installationsaufwand beschränkt sich auf eine einzige Codezeile, die in die Konsole des Betriebssystems eingegeben wird (bei Windows-Betriebssystemen der Kommandozeileninterpreter cmd.exe). Benötigt wird lediglich der Befehl npm install und der Name des zu installierenden Moduls.

Alle verfügbaren Zusatzmodule für Node.js lassen sich über eine Suchfunktion auf der offiziellen Website von npm einsehen.

Soll beispielsweise das Drittanbietermodul colors installiert werden, navigieren Sie in der Konsole des Betriebssystems in ein gewünschtes Verzeichnis und bestätigen folgenden Befehl mit der Eingabetaste:

Im Rahmen der Installation erstellt npm in Ihrem Anwendungsverzeichnis das Unterverzeichnis node_modules. Dieses dient als Speicherort für alle weiteren Module, die Sie installieren möchten. Wird ein Modul im Verzeichnis node_modules angelegt, ändert sich dadurch dessen Baumstruktur. Änderungen dieser Art werden in einer automatisch generierten JSON-Datei (JavaScript Object Notation), der sogenannten package-lock, erfasst.

Um das nachinstallierte Modul in eine Anwendung zu laden, verwenden Sie die bereits eingeführte Funktion require(). Folgendes Codebeispiel zeigt, wie das color-Modul eingesetzt wird, um Ausgaben in der Node.js-Konsole farbig hervorzuheben:

Der Anwendungscode, den Sie sich bei npmjs.com herunterladen können, unterscheidet sich im Grunde nicht von dem Code, den Sie auf Basis von Node.js selbst programmieren. Jeder, der die JavaScript-Laufzeitumgebung nutzt, hat die Möglichkeit, Anwendungen zu programmieren und diese als Module via npm mit der Community zu teilen. Wir zeigen Ihnen, wie Sie dabei vorgehen: Zunächst erstellen wir im Rahmen eines kurzen Node.js-Server-Tutorials mit nur acht Codezeilen einen eigenen Webserver und zerlegen diesen, um den Anwendungscode einzubinden. Anschließend bereiten wir das Programm für die Veröffentlichung vor.

Eine Standardanwendung von Node.js ist die Entwicklung leichtgewichtiger Webserver. Ein simpler „Hello World!“-Server lässt sich dank des vorprogrammierten Moduls „http“ binnen Sekunden programmieren.

1. Anwendungscode schreiben: Alles, was Sie benötigen, um einen Webserver mit Node.js zu erstellen, sind die folgenden acht Zeilen JavaScript-Code. Geben Sie diese in einen Texteditor ein und speichern Sie die Anwendung als JavaScript-Datei in einem beliebigen Verzeichnis. In diesem Node.js-Server-Tutorial wird die Datei als webserver.js benannt und im Verzeichnis my_webserver abgelegt.

In Codezeile 1 wird das Webserver-Modul http durch die Funktion require() geladen und in der gleichnamigen Konstante http gespeichert.

Die listen-Funktion in Codezeile 12 dient dazu, den Webserver an die in Zeile 2 definierte Portnummer zu binden, und ermöglicht es zudem, einen Callback anzuhängen. In Zeile 13 nutzen wir diesen, um mit console.log eine Statusmeldung ins Terminal zu schreiben.

Sie haben mit webserver.js Ihre erste eigene Anwendung geschrieben. Im nächsten Kapitel zeigen wir Ihnen, wie Sie eigene Anwendungen als Module in andere Anwendungen einbinden.

Eigene Module werden ebenso wie Basismodule oder Drittanbietermodule über die require-Funktion eingebunden. Um dies zu verdeutlichen, zerlegen wir die soeben erstellte Webserver-Anwendung in zwei einzelne Dateien: eine Datei, die den Webserver-Code enthält, und eine Datei, die den Anwendungscode enthält. Anschließend binden wir den Anwendungscode als Modul in den Webserver-Code ein.

Um Ihren Webserver gemäß dem Prinzip Separation of Concerns (SoC) in zwei separate Anwendungen aufzuteilen, gehen sie wie folgt vor:

1. Anwendungscode für das Handling von Requests und Responses schreiben: Erstellen Sie eine JavaScript-Datei handle.js nach folgendem Vorbild und speichern Sie diese im Verzeichnis my_webserver.

Die Datei handle.js enthält den Teil ihrer Webserver-Anwendung, der für das Handling von Requests und Responses zuständig ist. Sie umfasst somit im Wesentlichen die Callback-Funktion function(req, res), die Sie im vorangegangenen Beispiel innerhalb der Funktion http.createServer() inline definiert haben. Diese Callback-Funktion wird in der Konstante handle gespeichert. Um die als handle definierte Callback-Funktion auch außerhalb von handle.js verwenden zu können, müssen Sie diese als Modul exportieren. Node.js stellt dazu das Objekt module.exports zur Verfügung, mit dem sich beliebige Elemente (z. B. Funktionen, Strings, Objekte etc.) exportieren lassen.

2. Webserver-Code schreiben: Erstellen Sie eine JavaScript-Datei webserver1.js nach folgendem Vorbild und speichern Sie diese in Ihrem Anwendungsverzeichnis my_webserver.

Der Code entspricht im Wesentlichen dem der Webserver-Anwendung aus dem vorigen Beispiel. Doch statt das Handling von Requests und Responses inline in der createServer-Funktion zu definieren, verweisen Sie in Zeile 5 auf das zuvor erstellte Modul handle (die Dateiendung .js kann weggelassen werden). Damit die Ressource handle im Rahmen des Programmablaufs zur Verfügung steht, muss diese via require() als Modul eingebunden werden. Da sich beide Dateien im aktuellen Arbeitsverzeichnis befinden, verwenden wir den relativen Dateipfad ./handle. Absolute Dateipfade werden in Node.js-Projekten in der Regel nicht verwendet.

3. Webserver-Anwendung ausführen: Öffnen Sie die Windows-Eingabeaufforderung, navigieren Sie in das Verzeichnis my_webserver und führen Sie die JavaScript-Datei webserver1.js mit folgendem Befehl aus:

Sofern das Modul handle korrekt eingebunden wurde, erscheint die Statusmeldung: „Server is available under http://127.0.0.1:8080“. Rufen Sie diese Adresse auf, erhalten Sie: „Hello World!“.

Möchten Sie selbstentwickelte Anwendungen oder Programmteile auch anderen Node.js-Nutzern zur Verfügung stellen, empfiehlt sich eine Veröffentlichung via npm. Die npm-Registry dient der Community als zentrales Archiv für Drittanbietermodule. Prinzipiell kann jeder Node.js-Nutzer Module bereitstellen. Voraussetzung dafür ist eine kostenlose Registrierung bei npm.

Um sich bei npm zu registrieren, gehen Sie folgendermaßen vor:

1. Rufen Sie die npm-Startseite auf.
2. Füllen Sie das Registrierungsformular aus und senden Sie dieses ab.
3. Bestätigen Sie Ihre E-Mail-Adresse.

Sie können sich nun über die Weboberfläche unter www.npmjs.com anmelden. Alternativ stellt npm den folgenden Befehl zur Anmeldung über der Terminal zur Verfügung:

Bei jedem Log-in über das Terminal werden Ihr Benutzername, Ihr Passwort sowie ihre E-Mail-Adresse abgefragt. Nachdem Sie sich über das Terminal angemeldet haben, können Sie beliebig viele Node.js-Module veröffentlichen.

Voraussetzung für die Veröffentlichung eines Moduls ist, dass dieses eine vollständige package.json enthält, in der sämtliche Metadaten zum Modul erfasst wurden. Zu den Standardangaben in dieser Metadaten-Datei gehören u. a. folgende Informationen:

• name: Der Name Ihres Moduls (Pflicht)
• version: Die Versionsnummer Ihres Moduls (Pflicht)
• description: Eine kurze Beschreibung Ihres Moduls
• entry point: Die Einstiegsdatei Ihrer Anwendung (z. B. index.js)
• test command: Ein Kommando, mit dem sich Tests starten lassen (falls vorhanden)
• git repository: URL zu einem Git-Repository, z. B. GitHub (falls vorhanden)
• keywords: Schlüsselwörter, die der Auffindbarkeit über die npm-Suchfunktion dienen
• author: Ihr Name
• license: Die Lizenz, unter der das Projekt veröffentlicht wird (z. B. MIT)

Node.js-Anwender, die die package.json nicht von Hand schreiben möchten, können auf folgenden Kommandozeilenbefehl zurückgreifen:

Dieser startet ein Kommandozeilenprogramm, das grundlegende Metadaten im interaktiven Modus abfragt und anschließend eine JSON-Datei nach folgendem Schema erstellt:

Beachten Sie: Die via npm init erstellte package.json muss in der Regel manuell ergänzt werden – beispielsweise um eine Liste der Drittanbietermodule, die für den Programmablauf benötigt werden. Diese werden unter dependencies (Abhängigkeiten) erfasst.

Im aktuellen Beispiel wird eine Abhängigkeit zum Drittanbietermodul express in der Version 4.2.x ausgewiesen.

Erst die in der package.json hinterlegten Metadaten ermöglichen es, ein Modul via Name und Versionsnummer eindeutig zu identifizieren. Darüber hinaus stellt die package.json anderen Node.js-Anwendern alle Informationen bereit, die diese benötigen, um das Modul zu benutzen und die erforderlichen Abhängigkeiten bereitzustellen. Denn jedes Modul wird prinzipiell ohne node_modules-Ordner in die Registry geladen. Kommt ein Drittanbietermodul zum Einsatz, nutzt Node.js stattdessen die Angaben unter dependencies, um erforderliche Module automatisch nachzuladen. Diese Metainformation sollten Sie somit immer angeben, wenn Sie eigene Drittanbietermodule in Ihre Anwendung einbinden.

Sofern Sie alle relevanten Metadaten in der package.json hinterlegt haben, steht der Veröffentlichung Ihrer Anwendung nichts mehr im Weg. Der Upload in die npm-Registry erfolgt in drei einfachen Schritten:

1. Log-in: Melden Sie sich über das Terminal bei npm an.

2. Anwendung auswählen: Navigieren Sie in das Verzeichnis der Anwendung, die Sie als Modul veröffentlichen möchten.
   
   
3. Modul veröffentlichen: Geben Sie folgenden Befehl ins Terminal ein und bestätigen Sie mit Enter:

Der Befehl npm publish packt das ausgewählte Modul (Anwendungscode und package.json) als tar-Archiv und lädt dieses in die npm-Registry hoch.

Beachten Sie: Module, die einmal veröffentlicht wurden, lassen sich nur innerhalb der ersten 24 Stunden nach Veröffentlichung entfernen. Nutzen Sie dafür folgenden Befehl:

Bei einem Callback handelt es sich um eine Rückruf-Funktion, die im Rahmen von Node.js immer dann zum Einsatz kommt, wenn eine Aufgabe ausgelagert und somit JavaScript-Code asynchron ausgeführt werden soll (z. B. im Fall einer I/O-Operation). Callback-Funktionen haben die Aufgabe, sich zu melden, sobald eine delegierte Operation abgeschlossen wurde, und das Ergebnis zurückzugeben. In der Regel werden Callbacks so implementiert, dass eine Fehlermeldung ausgegeben wird, sofern die delegierte Aufgabe nicht wie gewünscht ausgeführt werden konnte.

Dabei ist zu beachten, dass Callback-Funktionen nicht zwangsläufig asynchron sind. Zwar kommen Callbacks immer dann zum Einsatz, wenn Programmcode asynchron ausgeführt werden soll. Dass Callbacks immer auf asynchronen Code hindeuten, wäre im Umkehrschluss jedoch falsch.

Der Unterschied zwischen einer synchronen und einer asynchronen Ausführung von Programmcode lässt sich an Beispielen verdeutlichen. Gehen Sie folgendermaßen vor, um eine Datei synchron einzulesen:

1. Textdatei erstellen: Legen Sie eine Textdatei input_sync.txt mit beliebigem Inhalt an – beispielsweise:

Speichern Sie diese in einem beliebigen Verzeichnis auf Ihrem System.

2. Anwendung schreiben: Schreiben Sie eine einfache JavaScript-Anwendung nach folgendem Beispiel und legen Sie diese unter app_sync.js im selben Verzeichnis ab.

3. Anwendung ausführen: Öffnen Sie die Windows-Eingabeaufforderung, navigieren Sie in das Verzeichnis, in dem Sie die Anwendung und die Textdatei gespeichert haben, und führen Sie app_sync.js mit folgendem Befehl aus:

In der Konsole erhalten Sie diese Ausgabe:

Der Programm-Code von app_sync.js wird sequenziell, d. h. von oben nach unten, abgearbeitet. Zunächst werden die Daten aus der input_sync.txt via fs.readFileSync() ins Programm geladen und anschließend mithilfe der Funktion console.log() auf die Standardausgabe geschrieben (in der Regel das Terminal). Erst wenn diese I/O-Operation abgeschlossen ist, fährt das Programm mit der zweiten console.log-Funktion fort, die den String „Program Ended“ ins Terminal schreibt.

Gehen Sie so vor, um eine Callback-Funktion asynchron auszuführen:

1. Textdatei erstellen: Legen Sie eine zweite Textdatei input2.txt mit beliebigem Inhalt an – beispielsweise:

Speichern Sie diese Textdatei im selben Verzeichnis wie die anderen Dateien.

2. Anwendung schreiben: Schreiben Sie eine zweite JavaScript-Anwendung nach folgendem Beispiel und legen Sie diese unter app_async.js im selben Verzeichnis ab.

3. Anwendung ausführen: Führen Sie app_async.js mit folgendem Befehl aus:

In der Konsole erhalten Sie folgende Ausgabe:

Auch der Programm-Code app_async.js wird sequenziell von oben nach unten ausgeführt. Anders als bei app_sync.js wartete das Programm jedoch nicht, bis die I/O-Operation in Zeile 2 abgeschlossen ist, sondern fährt, nachdem die Aufgabe an das Dateisystem delegiert wurde, ohne Verzögerung mit der Ausführung des weiteren Programm-Codes fort. Da die I/O-Operation länger dauert als die Ausführung der console.log-Funktion in Zeile 6, erhalten wir zunächst den String „Program Ended“ und erst danach das Ergebnis der I/O-Operation.

Um Objekte zu generieren, die Events auslösen und verarbeiten können, stellt Node.js im Basismodul events die Klasse EventEmitter zur Verfügung. Diese ermöglicht es Programmierern, eigene Klassen für eventauslösende Objekte abzuleiten sowie Objekte zu erzeugen, die automatisch die eventauslösende Funktion emit() erben.

In folgendem Beispiel binden wir das events-Modul über die Funktion require() ein und speichern dieses als EventEmitter-Klasse in einer Konstante ab. Anschließend nutzen wir extends, um aus der Klasse EventEmitter eine eigene eventauslösende Klasse myEmitter abzuleiten. Das eigentliche Event-Objekt erzeugen wir mithilfe des Operators new.

Um Objekte mit der Fähigkeit auszustatten, auf Events zu reagieren, stellt die EventEmitter-Klasse die Funktion on() zur Verfügung. Diese nimmt zwei Parameter entgegen: Der erste Parameter enthält den Namen des Events, auf das gelauscht werden soll, und registriert das Objekt somit für das entsprechende Event. Der zweite Parameter besagt, wie auf das Event reagiert werden soll. Dazu wird Objekten mit dem zweiten Parameter ein sogenannter Event-Handler „angehängt“, eine Callback-Funktion, die immer dann aufgerufen wird, wenn das gewünschte Event eintritt.

Soll das Event-Objekt Events auslösen, kommt die Funktion emit() zum Einsatz. Die emit-Funktion erwartet einen Parameter, der den Namen des Events beinhaltet. Weitere optionale Parameter können Daten zum Event enthalten, die an die Event-Handler-Funktion weitergegeben werden.

Bei einem Stream handelt es sich um die Abstraktion einer Datensequenz, die es Node.js erlaubt, große Datenmengen effizient zu verarbeiten. Konzeptionell lassen sich Streams mit Arrays vergleichen. Doch während Arrays alle zu verarbeitenden Daten zeitgleich als Werte im Arbeitsspeicher vorhalten, werden diese bei Streams Stück für Stück verarbeitet, sodass immer nur ein Teil der Daten in den Arbeitsspeicher geladen werden muss.

Statt wie bei Arrays in räumlicher Abfolge werden Daten in Streams somit in zeitlicher Abfolge vorgehalten. Diese Art der Datenverarbeitung ermöglicht es Node.js, mit Datenmengen umzugehen, deren Größe den zur Verfügung stehenden Arbeitsspeicher deutlich überschreitet. Ein weiterer Vorteil ist die Reduktion der Latenzzeit. Um auf Daten aus einem Array zugreifen zu können, muss ein Programm warten, bis dieses komplett geladen ist. Streams hingegen stellen Daten kontinuierlich bereit, sobald die ersten Bytes eingetroffen sind, und laden den Rest im Hintergrund nach.

Das Konzept des Streams geht auf die Interprozesskommunikation in der UNIX-Shell zurück. Unter UNIX sind Streams über die Pipe (|) in die Shell implementiert. Diese ermöglicht es, Daten von einem Prozess an einen anderen zu übergeben. Auch Node.js bietet mit dem Basismodul stream eine API für die Datenverarbeitung via Stream. Anwendern stehen zwei Basistypen von Streams zur Verfügung: Readable Streams und Writable Streams. Auf diesen aufbauend, lassen sich darüber hinaus sogenannte Duplex- und Transform-Streams realisieren, die eine Kombination beider Basis-Streams darstellen.

Für alle Stream-Typen stellt Node.js über das stream-Modul jeweils eine Basisklasse zur Verfügung, die Eigenschaften von der EventEmitter-Klasse erbt. Jeder Stream ist somit auch ein EventEmitter. Im Code werden Streams als Objekte realisiert, die in der Lage sind, Events auszulösen. Zu den wichtigsten Events für den Umgang mit Streams zählen data-, end-, error- und finish-Events.

Im Folgenden veranschaulichen wir den Umgang mit Streams am Beispiel der beiden Basis-Stream-Typen.

Readable Streams kommen im Rahmen eines Programms zum Einsatz, um Daten aus einer Quelle auszulesen. Mögliche Datenquellen für diesen Stream-Typ sind das Dateisystem, Netzwerk-Endpunkte oder In-Memory-Datenstrukturen.

Wie alle Streams sind auch Readable Streams im JavaScript-Code als Objekte repräsentiert, die zunächst erzeugt werden müssen. Eine Funktion, um Readable Streams zu erzeugen, wird beispielsweise durch das fs-Modul bereitgestellt, das Node.js eine Interaktion mit dem Dateisystem ermöglicht. Im Beispiel zeigen wir Ihnen in drei Schritten, wie Sie Readable Streams nutzen, um Daten aus einer Textdatei auszulesen und in Form eines Strings ins Terminal zu schreiben.

1. Inputdatei erstellen: Erstellen Sie eine Textdatei input.txt mit beliebigem Inhalt und legen Sie diese in einem Verzeichnis ihrer Wahl ab.
   
   
2. Anwendungscode schreiben: Erstellen Sie eine JavaScript-Anwendung nach folgendem Vorbild und speichern Sie diese unter read-stream.js im selben Verzeichnis wie die input.txt.

Zunächst nutzen Sie die Funktion require(), um das fs-Modul zu laden. Dieses hält die Funktion fs.createReadStream() bereit, mit der Sie Streams für Lesezugriffe auf das Dateisystem erzeugen. Die Funktion fs.createReadStream() erwartet als ersten Parameter den Pfad zur Datei, die Sie auslesen möchten. Ein zweiter Parameter mit Optionen ist fakultativ. In der Regel kommt ein Encoding zum Einsatz.

Für das aktuelle Beispiel erzeugen wir einen Stream mit dem Namen MyReadableStream auf die Datei input.txt und nutzen dabei ein utf8-Encoding. Die Funktion fs.createReadStream() hat somit zwei Aufgaben: Zum einen sorgt sie im Rahmen des Programmablaufs dafür, dass die Daten blockweise aus der Datei in den Stream gelesen werden. Und zum anderen gibt sie vor, in welcher Kodierung die ausgelesenen Daten im Stream vorgehalten werden sollen. Wird das Encoding weggelassen, lädt fs.createReadStream() reine Binärdaten in den Stream.

Das Streaming der Daten erfolgt Block für Block. Jedes Mal, wenn die ausgelesenen Daten eine von Node.js vordefinierte Blockgröße erreicht haben, wird an dem Stream MyReadableStream ein data-Event ausgelöst. Auf dieses Event reagieren Sie, indem Sie mithilfe der on-Funktion einen Callback anhängen. Im aktuellen Beispiel nutzen wir die Funktion console.log(). Die ausgelesenen Datenblöcke werden auf das Terminal ausgegeben.

Zusätzlich zu data-Events können Readable Streams error- und end-Events auslösen, auf die Sie ebenfalls reagieren sollten. Das error-Event wird bei Readable Streams immer dann ausgelöst, wenn Lesefehler auftreten. Es empfiehlt sich, eine console.log-Funktion via on() anzuhängen, die die Fehlermeldung im Terminal ausgibt. Zum end-Event kommt es, sobald die Datenquelle vollständig ausgelesen wurde und der Readable Stream keine weiteren Datenblöcke bereitstellen kann. Reagieren Sie auf das end-Event ebenfalls mit einer console.log()-Funktion, um sich eine Statusmeldung auf das Terminal ausgeben zu lassen.

3. Anwendungscode ausführen: Öffnen Sie die Windows-Eingabebestätigung, navigieren Sie in das gewählte Verzeichnis und starten Sie read-stream.js mit folgendem Kommando:

Writable Streams nehmen Daten blockweise entgegen und ermöglichen es Ihnen, diese in einen beliebigen Zielspeicherort – beispielsweise eine Datei oder einen anderen Stream – zu schreiben. Wie Readable Streams sind auch Writable Streams Ableitungen der EventEmitter-Klasse und somit in der Lage, Events auszulösen. Diese spielen beim Umgang mit Writable Streams jedoch eine untergeordnete Rolle.

Zentrale Elemente dieses Stream-Typs sind stattdessen die Funktionen write() und end(), die in jedem Fall implementiert sein müssen. Die Funktionsweise des Writable Streams veranschaulichen wir am Beispiel einer einfachen Dateioperation, bei der wir Textelemente aus dem Programm-Code einer JavaScript-Anwendung mithilfe eines Streams in eine Textdatei schreiben.

1. Anwendungscode schreiben: Erstellen Sie eine JavaScript-Anwendung nach folgendem Vorbild und speichern Sie diese unter write-stream.js in einem beliebigen Verzeichnis ab.

Wie Readable Streams lassen sich auch Writable Streams mithilfe des moduls fs erzeugen, das sie über die Funktion require() in Ihre Anwendung laden. Nutzen Sie dazu die Funktion fs.createWriteStream(). Auch diese Funktion erwartet als ersten Parameter einen Pfad bzw. einen Dateinamen, der angibt, wo die Streaming-Daten gespeichert werden sollen.

Wenn die Datei output.txt noch nicht existiert, wird diese im Rahmen der Programmausführung automatisch erstellt. Andernfalls überschreibt der Writable Stream eine bereits existierende Datei mit gleichem Namen. Setzen Sie auch bei Writable Streams den optionalen Parameter für das Encoding. Anders als beim Readable Stream kommt dazu das Keyword defaultEncoding zum Einsatz.

Sobald der Writable Stream auf die Datei output.txt erzeugt wurde, können Sie die Funktion write() nutzen, um Daten blockweise in den Stream zu schreiben. Solange der Writable Stream geöffnet ist, kann die write-Funktion beliebig oft aufgerufen werden. Dies ermöglicht Ihnen, Daten nach und nach in den Stream zu schreiben. Möchten Sie keine weiteren Daten in den Stream schreiben, schließen Sie diesen mit der end-Funktion ab.

Auch Writable Streams lösen Ereignisse aus. In der Beispielanwendung reagieren wir auf das finish- und das error-Event. Das finish-Event wird immer dann ausgelöst, wenn alle Streaming-Daten erfolgreich in das Speicherziel geschrieben wurden. Möchten Sie sich in diesem Fall eine Statusmeldung (z. B. Write completed) ausgeben lassen, hängen Sie dem finish-Event via on() eine entsprechende console.log()-Funktion an.

Wie Readable Streams lösen auch Writable Streams error-Events aus, sofern beim Schreibprozess ein Fehler auftritt. Hängen Sie diesem Event ebenfalls eine console.log-Funktion an, um die Fehlermeldung als Terminalausgabe zu erhalten.

2. Anwendungscode ausführen: Öffnen Sie die Windows-Eingabeaufforderung, navigieren Sie in das gewählte Verzeichnis und starten Sie write-stream.js mit folgendem Kommando:

Eine zentrale Funktionalität serverseitiger Anwendungen ist die Interaktion mit Datenbanken. Auch für Node.js stehen Drittanbietermodule bereit, mit denen sich Datenbanken ansprechen und Datenbankoperationen ausführen lassen.

Welche Datenbank-Management-Systeme dabei zum Einsatz kommen, ist Geschmackssache. Ein Großteil der Node.js-Anwender setzt jedoch auf MongoDB – und das aus gutem Grund. Bei MongoDB handelt es sich um eine dokumentenorientierte, nichtrelationale NoSQL-Datenbank. Die plattformübergreifende Software ist in C++ geschrieben und speichert Daten schemalos als BSON-Objekte, die in der Terminologie von MongoDB als Dokumente bezeichnet werden. Das Format BSON (Binary JSON) ist dem JSON-Format nachempfunden und stattet MongoDB mit einer nativen JavaScript-Kompatibilität aus. Für Anwender bedeutet das: Die Interaktion mit der Datenbank kann ebenso wie die Programmierung von Node.js-Anwendungen in JavaScript erfolgen. Eine zusätzliche Datenbanksprache wie SQL (Structured Query Language) wird nicht benötigt.

MongoDB wird der Gruppe der NoSQL-Datenbanken zugeordnet. Das Kürzel „NoSQL“ steht – anders als zu erwarten wäre – für „Not only SQL“ und kennzeichnet Datenbanken, die einem nichtrelationalen Ansatz folgen. Anders als relationale Datenbanken wie MySQL oder MariaDB nutzen diese kein festgelegtes Tabellenschema. Das bedeutet: Für Tabellen innerhalb von nichtrelationalen Datenbanken muss nicht festgelegt werden, welche Spalten es gibt oder welche Datentypen in diesen Spalten gespeichert werden können. Stattdessen werden die Daten ohne strukturelle Zuordnung in Tabellen abgelegt. Eine solche Datenbankarchitektur eignet sich vor allem für Anwendungen, bei denen große Datenmengen in kurzer Zeit verarbeitet werden müssen.

Der Einsatz von MongoDB bietet somit zahlreiche Vorteile. Mit Node.js sind Sie jedoch nicht auf dieses Datenbank-Management-System festgelegt. Sollte Ihr Webprojekt statt einer NoSQL-Datenbank eine SQL-basierte relationale Datenbank benötigen, lässt sich auch diese ohne weiteres als Modul einbinden.

Im Folgenden veranschaulichen wir den Umgang mit Datenbanken am Beispiel von MongoDB und der meistverwendeten relationalen Datenbank MySQL. Eine Gegenüberstellung beider Datenbank-Management-Systeme finden Sie im Grundlagenartikel zu MongoDB.

Um mit einer Node.js-Anwendung auf MongoDB zugreifen zu können, benötigen Sie einen Datenbanktreiber. Das offizielle MongoDB-Modul für Node.js steht per npm zur Verfügung und lässt sich wie oben beschrieben installieren:

Im Folgenden zeigen wir Ihnen, wie Sie MongoDB über eine Node.js-Anwendung ansprechen und im Rahmen des Programmablaufs Datenbankoperationen durchführen.

Damit Ihre Anwendung mit der Datenbank interagieren kann, müssen Sie zunächst eine Verbindung aufbauen. Wie Sie dabei vorgehen, zeigt folgendes Codebeispiel:

Zunächst rufen Sie das offizielle mongodb-Modul für Node.js über die Funktion require() auf und speichern dieses in der Konstante mongodb.

Für die Interaktion mit der Datenbank stellt das Modul mongodb die Klasse MongoClient zur Verfügung. Auch diese speichern Sie in einer gleichnamigen Konstante. Diese fungiert später als Referenz und ermöglicht es, mit dem MongoClient zu interagieren.

Anschließend definieren Sie einen sogenannten connectionString. Dieser beinhaltet alle Informationen, die für den Zugriff auf die Datenbank benötigt werden: Benutzernamen und Passwort (optional), die IP-Adresse des Rechners, auf dem sich die Datenbank befindet (im aktuellen Beispiel localhost), der Port, über den Sie auf die Datenbank zugreifen möchten (standardmäßig 27017; kann weggelassen werden), sowie einen freiwählbaren Datenbanknamen.

Im nächsten Schritt übergeben Sie den connectionString dem MongoClient. Dazu sprechen Sie diesen über die zuvor definierte Konstante an und rufen die Funktion connect() auf.

Im aktuellen Beispiel werden dem MongoClient zusätzlich zum connectionString zwei weitere Parameter übergeben: das Objekt autoReconnect: true, das bei Verbindungsabbrüchen automatisch eine Neuverbindung einleitet, sowie ein Callback. Tritt ein Fehler auf, gibt dieser eine Meldung auf das Terminal aus und beendet das Programm. Sofern kein Fehler auftritt, ruft der Callback die abschließende console.log-Funktion auf, die Ihnen den Verbindungsstatus „Connected!“ auf das Terminal ausgibt.

In der Terminologie von MongoDB werden die schemalosen Tabellen innerhalb einer Datenbank Collections genannt. Zugriff auf eine Collection erhalten Sie durch die gleichnamige, vom mongodb-Modul bereitgestellte Funktion collection().

In folgendem Beispiel greifen wir auf die Collection users zu.

Beachten Sie: Wenn Sie eine Collection ansprechen, die noch nicht existiert, erzeugt MongoDB diese automatisch.

Datensätze werden in der Terminologie von MongoDB Dokumente genannt und als BSON-Objekte gespeichert. Gehen Sie wie folgt vor, um ein Dokument in einer Collection abzulegen.

Definieren Sie zunächst ein Dokument – beispielsweise das Dokument user:

Speichern Sie das Dokument mithilfe der Funktion insertOne() in der eben angelegten Tabelle.

Im aktuellen Beispiel speichern wir das Dokument user in der zuvor angelegten Tabelle users und hängen darüber hinaus eine Callback-Funktion an. Diese gibt im Fall eines Fehlers eine entsprechende Meldung aus und beendet das Programm. Wurde das Dokument erfolgreich in die Collection eingefügt, erhalten wir über eine console.log-Funktion die Statusmeldung „Successfully inserted user!“. Anschließend wird die Datenbankverbindung mithilfe der Funktion close geschlossen.

Datenbankabfragen laufen bei MongoDB über die find-Funktion. Mit dieser können Sie entweder einzelne oder alle Dokumente in einer Collection abfragen.

Mit folgendem Codebeispiel werden alle Dokumente der Collection users abgerufen und als Array auf das Terminal ausgegeben:

Möchten Sie ein bestimmtes Dokument einer Collection abrufen, nutzen Sie die Funktion find() in Kombination mit einem Suchparameter.

m aktuellen Beispiel werden lediglich die Dokumente der Collection users ausgegeben, die ein Feld firstName mit dem Inhalt John aufweisen.

Möchten Sie hingegen lediglich das erste Dokument abfragen, auf das das Suchkriterium zutrifft, verwenden Sie statt find() die Funktion findOne().

Um Ihnen das Löschen von Dokumenten zu ermöglichen, bietet das Modul mongodb die Funktionen deleteMany() und deleteOne(). Während deleteOne() lediglich das erste Dokument löscht, auf das das Suchkriterium zutrifft, löscht deleteMany() alle Dokumente mit entsprechender Übereinstimmung.

Die Funktionen deleteMany() und deleteOne() erwarten den Parameter filter.

Nutzen Sie die deleteOne-Funktion nach folgendem Beispiel, um das erste Dokument zu löschen, das das Suchkriterium erfüllt:

Sollten Sie alle Dokumente löschen wollen, die die in der filter-Konstante definierten Kriterien erfüllen, ersetzen Sie die deleteOne-Funktion durch deleteMany():

Möchten Sie Dokumente aktualisieren, nutzen Sie die Funktionen updateOne() und updateMany(). Diese erwarten zwei Parameter: einen filter-Parameter, mit dem Sie definieren, welche Dokumente Sie aktualisieren möchten, und einen update-Parameter, mit dem Sie definieren, womit Sie die ausgewählten Dokumente überscheiben möchten. Während updateOne() lediglich das erste Dokument überschreibt, auf das das Suchkriterium zutrifft, überschreibt updateMany() alle Dokumente mit entsprechender Übereinstimmung.

Möchten Sie ein Dokument aktualisieren, definieren Sie zunächst die Parameter filter und update.

Anschließend rufen Sie die Funktion updateOne() auf.

Im aktuellen Beispiel ersetzen wir das erste Dokument mit den Feldern firstName: 'John' und lastName: 'Doe' mit einem Dokument mit den Feldern firstName: 'John Thomas' und lastName: 'Doe'. Beachten Sie, dass Dokumente immer komplett überschrieben werden. Der Parameter update gibt somit an, wie das ausgewählte Dokument nach der Aktualisierung aussehen soll. Möchten Sie lediglich einzelne Datenfelder eines Dokuments ersetzen, müssen Sie ein partielles Update durchführen. Nutzen Sie dazu den Update-Operator $set.

Im aktuellen Beispiel gibt der Operator $set an, dass im ersten Dokument, auf das das Filterkriterium zutrifft, lediglich der Wert im Datenfeld firstName durch John Thomas ersetzt werden soll.

Möchten Sie mehrere Datensätze mit updateMany() aktualisieren, muss immer ein Update-Operator verwendet werden. Weitere Informationen zu den Update- und Abfrage-Operatoren von MongoDB finden Sie in der Dokumentation des Datenbank-Management-Systems.

Folgendes Codebeispiel zeigt, wie Sie das Modul mysql nutzen, um eine Datenbankverbindung zu einer Node.js Anwendung aufzubauen.

Zunächst laden Sie das Modul mysql in Ihre Anwendung und speichern dieses in der Konstante mysql. Beachten Sie, dass auch dieses zuvor via npm auf ihrem System installiert werden muss.

Anschließend nutzen Sie die im mysql-Modul enthaltene Funktion createConnection(), um die Verbindungsdaten zur Datenbank zu definieren. Benötigt werden folgende Angaben: der Name des Servers (oder die IP-Adresse), auf dem die Datenbank liegt, Ihr Benutzername, Ihr Passwort sowie der Name der Datenbank, auf die Sie zugreifen möchten.

Damit Sie später auf die Funktion createConnection() sowie auf die als Parameter hinterlegten Verbindungsdaten zugreifen können, speichern Sie diese in der Konstante connection.

Der eigentliche Verbindungsaufbau erfolgt in Zeile 9. Dazu sprechen Sie die Konstante connection an und rufen die vom mysql-Modul bereitgestellte Funktion connect() auf. Dieser hängen Sie eine Callback-Funktion an, die eine Statusmeldung auf das Terminal ausgibt.

Im Falle eines Fehlers erhalten Sie eine Fehlermeldung als Terminalausgabe. Anschließend wird das Programm beendet. War der Verbindungsaufbau erfolgreich, gibt die Anwendung den Status „Connected!“ aus.

Im Rahmen von Datenbankoperationen sprechen Sie ebenfalls die Konstante connnection an, die Sie im vorhergehenden Beispiel definiert haben, um auf createConnection() sowie auf die Parameter für den Verbindungsaufbau zuzugreifen. Alle Datenbankoperationen erfolgen mithilfe der Funktion query(). Diese erwartet als ersten Parameter ein SQL-Statement, das angibt, welche Operation durchgeführt werden soll und auf welche Daten sich diese bezieht. Die eigentliche Interaktion mit der Datenbank erfolgt somit in der Datenbanksprache SQL. Das SQL-Statement kann inline definiert oder in eine Variable/Konstante ausgelagert werden.

Inline:

Ausgelagertes SQL-Statement:

Der zweite Parameter der query-Funktion ist ein Callback mit drei Argumenten:

• err speichert Fehler, die während der Ausführung des SQL-Statements auftreten.
• results enthält die Ergebnisse der Abfrage.
• fields enthält Detailinformationen zu den betroffenen Datenfeldern.

Detaillierte Informationen dazu, wie Sie eine MySQL-Datenbank einrichten und SQL-Statements formulieren, um Datenbankoperationen durchzuführen, entnehmen Sie unserem MySQL-Tutorial für Einsteiger.