Wie man seine erste Anwendung in Node.js schreibt und ausführt

Einführung

Node.js ist eine beliebte Open-Source-Laufzeitumgebung, die JavaScript außerhalb des Browsers mithilfe der V8-JavaScript-Engine ausführen kann. Diese Engine wird auch im Google Chrome-Browser verwendet. Die Node-Laufzeitumgebung wird häufig zur Entwicklung von Kommandozeilenprogrammen und Webservern eingesetzt.

Das Erlernen von Node.js ermöglicht es Ihnen, Ihren Frontend- und Backend-Code in derselben Sprache zu schreiben. Die durchgängige Verwendung von JavaScript kann die Zeit für Kontextwechsel verkürzen, und Bibliotheken lassen sich einfacher zwischen Backend-Server und Frontend-Projekten teilen.

Dank seiner Unterstützung für asynchrone Ausführung eignet sich Node.js hervorragend für E/A-intensive Aufgaben und ist daher ideal für Webanwendungen. Echtzeitanwendungen wie Videostreaming oder Anwendungen, die ständig Daten senden und empfangen, laufen in Node.js deutlich effizienter.

In diesem Tutorial erstellen Sie Ihre erste Anwendung mit der Node.js-Laufzeitumgebung. Sie lernen einige spezifische Node-Konzepte kennen und entwickeln eine Anwendung, mit der Benutzer die Umgebungsvariablen ihres Systems überprüfen können. Dazu lernen Sie, wie Sie Zeichenketten in der Konsole ausgeben, Benutzereingaben entgegennehmen und auf Umgebungsvariablen zugreifen.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie Folgendes:

• Node.js ist auf Ihrem Entwicklungsrechner installiert. Dieses Tutorial verwendet Node.js Version 10.16.0. Um Node.js unter macOS oder Ubuntu 18.04 zu installieren, folgen Sie den Schritten unter «Node.js installieren und eine lokale Entwicklungsumgebung unter macOS erstellen» bzw. dem Abschnitt „Installation über ein PPA“ unter „Node.js unter Ubuntu 18.04 installieren“.
• Grundlegende JavaScript-Kenntnisse finden Sie hier: Wie man in JavaScript programmiert.

Schritt 1 – Ausgabe auf der Konsole

Um ein “Hallo Welt!”-Programm zu schreiben, öffnen Sie einen Befehlszeilen-Texteditor wie nano und erstellen Sie eine neue Datei:

nano hello.js

Wenn sich der Texteditor öffnet, geben Sie folgenden Code ein:

console.log("Hello World");

Das Konsolenobjekt in Node.js bietet einfache Methoden zum Schreiben in stdout, stderr oder einen anderen Node.js-Stream, in den meisten Fällen die Kommandozeile. Die Methode `log` gibt die Ausgabe in den stdout-Stream aus, sodass sie in der Konsole sichtbar ist.

In Node.js sind Streams Objekte, die Daten empfangen können, wie beispielsweise der stdout-Stream, oder Objekte, die Daten ausgeben können, wie ein Netzwerk-Socket oder eine Datei. Bei stdout- und stderr-Streams werden alle an sie gesendeten Daten in der Konsole angezeigt. Ein wichtiger Vorteil von Streams ist ihre einfache Umleitungsfähigkeit. So können Sie beispielsweise die Ausgabe Ihres Programms in eine Datei umleiten.

Speichern und beenden Sie nano durch Drücken von STRG+X. Wenn Sie zum Speichern der Datei aufgefordert werden, drücken Sie Y. Ihr Programm ist nun lauffähig.

Schritt 2 – Programm ausführen

Um dieses Programm auszuführen, verwenden Sie den Node-Befehl wie folgt:

node hello.js

Das Programm hello.js wird ausgeführt und zeigt folgende Ausgabe an:

Output
Hello World

Der Node.js-Interpreter las die Datei und führte `console.log("Hello World")` aus, indem er die `log`-Methode des globalen `console`-Objekts aufrief. Die Zeichenkette "Hello World" wurde als Argument an die `log`-Funktion übergeben.

Obwohl die Anführungszeichen im Code notwendig sind, um anzuzeigen, dass es sich bei dem Text um eine Zeichenkette handelt, werden sie auf dem Bildschirm nicht angezeigt.

Nachdem wir uns vergewissert haben, dass das Programm funktioniert, wollen wir es interaktiver gestalten.

Schritt 3 – Benutzereingaben über Befehlszeilenargumente erhalten

Jedes Mal, wenn Sie Node.js “Hello, World!” ausführen, erzeugt das Programm die gleiche Ausgabe. Um das Programm dynamischer zu gestalten, wollen wir Benutzereingaben entgegennehmen und diese auf dem Bildschirm anzeigen.

Kommandozeilenprogramme akzeptieren oft verschiedene Argumente, die ihr Verhalten beeinflussen. Beispielsweise gibt die Ausführung von Node.js mit dem Argument `--version` die installierte Version aus, anstatt den Interpreter zu starten. Damit haben Sie Ihren Code über Kommandozeilenargumente akzeptiert.

Erstellen Sie mit nano eine neue arguments.js-Datei:

nano arguments.js

Geben Sie folgenden Code ein:

console.log(process.argv);

Das Prozessobjekt ist ein globales Node.js-Objekt, das Funktionen und Daten enthält, die alle mit dem laufenden Node.js-Prozess zusammenhängen. Die argv-Eigenschaft ist ein Array von Zeichenketten, das alle an ein Programm übergebenen Kommandozeilenargumente enthält.

Speichern und beenden Sie nano durch Drücken von STRG+X, drücken Sie Y, wenn Sie zum Speichern der Datei aufgefordert werden.

Wenn Sie dieses Programm nun ausführen, geben Sie ein Kommandozeilenargument wie dieses an:

node arguments.js hello world

Die Ausgabe sieht wie folgt aus:

Output
[ '/usr/bin/node',
'/home/sammy/first-program/arguments.js',
'hello',
'world' ]

Das erste Argument im `process.argv`-Array ist immer der Pfad zur Node.js-Binärdatei, die das Programm ausführt. Das zweite Argument ist immer der Pfad zur auszuführenden Datei. Die übrigen Argumente sind die Benutzereingaben, in diesem Fall: „hello world“.

Uns interessieren die vom Benutzer eingegebenen Argumente mehr als die von Node.js bereitgestellten Standardargumente. Öffnen Sie die Datei arguments.js zum Bearbeiten:

nano arguments.js

Ändern Sie console.log(process.arg); in Folgendes:

console.log(process.argv.slice(2));

Da `argv` ein Array ist, können Sie die in JavaScript integrierte `slice`-Methode verwenden, die eine Sammlung von Elementen zurückgibt. Wenn Sie der `slice`-Funktion 2 als Argument übergeben, erhalten Sie alle Elemente von `argv` ab dem zweiten Element – also die vom Benutzer eingegebenen Argumente.

Führen Sie das Programm erneut mit dem Befehl „node“ und denselben Argumenten wie beim letzten Mal aus:

node arguments.js hello world

Das Ergebnis sieht nun wie folgt aus:

Output
[ 'hello', 'world' ]

Nachdem wir nun Eingaben vom Benutzer erfassen können, erfassen wir als Nächstes Eingaben aus der Anwendungsumgebung.

Schritt 4 – Zugriff auf Umgebungsvariablen

Umgebungsvariablen sind Schlüssel-Wert-Paare, die außerhalb einer Anwendung gespeichert und vom Betriebssystem bereitgestellt werden. Sie werden üblicherweise vom System oder Benutzer festgelegt und stehen allen laufenden Prozessen für Konfigurations- und Statuszwecke zur Verfügung. Sie können über das Node-Prozessobjekt darauf zugreifen.

Verwenden Sie nano, um eine neue Umgebungsdatei zu erstellen.

nano environment.js

Fügen Sie folgenden Code hinzu:

console.log(process.env);

Das env-Objekt speichert alle Umgebungsvariablen, die beim Ausführen einer Node.js-Anwendung verfügbar sind.

Speichern und beenden Sie die Datei wie zuvor und führen Sie die Datei environment.js mit dem Befehl node aus.

node environment.js

Nach dem Ausführen des Programms sollte eine Ausgabe ähnlich der folgenden angezeigt werden:

Output
{ SHELL: '/bin/bash',
SESSION_MANAGER:
'local/digitalocean:@/tmp/.ICE-unix/1003,unix/digitalocean:/tmp/.ICE-unix/1003',
COLORTERM: 'truecolor',
SSH_AUTH_SOCK: '/run/user/1000/keyring/ssh',
XMODIFIERS: '@im=ibus',
DESKTOP_SESSION: 'ubuntu',
SSH_AGENT_PID: '1150',
PWD: '/home/sammy/first-program',
LOGNAME: 'sammy',
GPG_AGENT_INFO: '/run/user/1000/gnupg/S.gpg-agent:0:1',
GJS_DEBUG_TOPICS: 'JS ERROR;JS LOG',
WINDOWPATH: '2',
HOME: '/home/sammy',
USERNAME: 'sammy',
IM_CONFIG_PHASE: '2',
LANG: 'en_US.UTF-8',
VTE_VERSION: '5601',
CLUTTER_IM_MODULE: 'xim',
GJS_DEBUG_OUTPUT: 'stderr',
LESSCLOSE: '/usr/bin/lesspipe %s %s',
TERM: 'xterm-256color',
LESSOPEN: '| /usr/bin/lesspipe %s',
USER: 'sammy',
DISPLAY: ':0',
SHLVL: '1',
PATH:
'/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin',
DBUS_SESSION_BUS_ADDRESS: 'unix:path=/run/user/1000/bus',
_: '/usr/bin/node',
OLDPWD: '/home/sammy' }

Beachten Sie, dass viele der angezeigten Umgebungsvariablen von Ihrer Systemkonfiguration und Ihren Einstellungen abhängen und Ihre Ausgabe deutlich von der hier gezeigten abweichen kann. Anstatt eine lange Liste von Umgebungsvariablen anzuzeigen, möchten Sie möglicherweise eine bestimmte Variable abrufen.

Schritt 5 – Zugriff auf eine bestimmte Umgebungsvariable

In diesem Schritt werden Sie die Umgebungsvariablen und ihre Werte mithilfe des globalen process.env-Objekts anzeigen und ihre Werte in der Konsole ausgeben.

Das `process.env`-Objekt ist eine einfache Zuordnung zwischen Umgebungsvariablennamen und ihren als Zeichenketten gespeicherten Werten. Wie bei allen Objekten in JavaScript greift man auf eine Eigenschaft zu, indem man ihren Namen in Klammern angibt.

Öffnen Sie die Datei environment.js zum Bearbeiten:

nano environment.js

Ändern Sie console.log(process.env); in:

console.log(process.env["HOME"]);

Speichern Sie die Datei und beenden Sie das Programm. Führen Sie nun die Anwendung environment.js aus:

node environment.js

Die Ausgabe sieht nun folgendermaßen aus:

Output
/home/sammy

Anstatt das gesamte Objekt auszugeben, geben Sie jetzt nur noch die HOME-Eigenschaft von process.env aus, die den Wert der Umgebungsvariablen $HOME speichert.

Beachten Sie, dass die Ausgabe dieses Codes wahrscheinlich von der hier gezeigten abweicht, da sie systemspezifisch ist. Nachdem Sie nun die abzurufende Umgebungsvariable festlegen können, können Sie Ihre Anwendung erweitern, indem Sie den Benutzer nach der gewünschten Variable fragen.

Schritt 6 – Ein Argument als Reaktion auf die Benutzereingabe abrufen

Als Nächstes werden Sie die Fähigkeit nutzen, Befehlszeilenargumente und Umgebungsvariablen zu lesen, um ein Befehlszeilentool zu erstellen, das den Wert einer Umgebungsvariablen auf dem Bildschirm ausgibt.

Verwenden Sie nano, um eine neue echo.js-Datei zu erstellen:

nano echo.js

Fügen Sie folgenden Code hinzu:

const args = process.argv.slice(2);
console.log(process.env[args[0]]);

Die erste Zeile von echo.js speichert alle vom Benutzer angegebenen Kommandozeilenargumente in einer Konstanten namens `args`. Die zweite Zeile gibt die im ersten Element von `args` gespeicherte Umgebungsvariable aus, also das erste vom Benutzer angegebene Kommandozeilenargument.

Speichern und beenden Sie nano, und führen Sie das Programm anschließend wie folgt aus:

node echo.js HOME

Die Ausgabe lautet nun:

Output
/home/sammy

Das HOME-Argument wurde im args-Array gespeichert, welches dann verwendet wurde, um seinen Wert in der Umgebung über das process.env-Objekt zu finden.

An diesem Punkt können Sie auf die Werte beliebiger Umgebungsvariablen Ihres Systems zugreifen. Um dies zu überprüfen, sehen Sie sich die folgenden Variablen an: PWD, USER, PATH.

Das Abrufen einzelner Variablen ist zwar in Ordnung, aber es ist besser, dem Benutzer die Möglichkeit zu geben, die Anzahl der gewünschten Variablen anzugeben.

Schritt 7 – Mehrere Umgebungsvariablen anzeigen

Das Programm kann derzeit nur eine Umgebungsvariable gleichzeitig prüfen. Es wäre hilfreich, wenn mehrere Kommandozeilenargumente akzeptiert und deren entsprechende Werte in der Umgebung abgerufen werden könnten. Verwenden Sie nano, um echo.js zu bearbeiten:

nano echo.js

Bearbeiten Sie die Datei so, dass sie stattdessen folgenden Code enthält:

const args = process.argv.slice(2);
args.forEach(arg => {
console.log(process.env[arg]);
});

Die `forEach`-Methode ist eine Standardmethode in JavaScript für alle Array-Objekte. Sie akzeptiert eine Callback-Funktion, die beim Durchlaufen jedes Elements des Arrays aufgerufen wird. Sie verwenden `forEach` für das `args`-Array und geben eine Callback-Funktion an, die den Wert des aktuellen Arguments in der Umgebung ausgibt.

Speichern und schließen Sie die Datei. Führen Sie das Programm nun erneut mit zwei Argumenten aus:

node echo.js HOME PWD

Sie sehen folgende Ausgabe:

[secondary_label Output] 
/home/sammy
/home/sammy/first-program

Die Funktion forEach stellt sicher, dass jedes Kommandozeilenargument im Array args ausgegeben wird.

Nun haben Sie eine Möglichkeit, die vom Benutzer angeforderten Variablen abzurufen, aber wir müssen noch Fälle behandeln, in denen der Benutzer ungültige Daten eingibt.

Schritt 8 – Umgang mit nicht spezifizierten Eingaben

Um zu sehen, was passiert, wenn Sie dem Programm ein Argument übergeben, das keine gültige Umgebungsvariable ist, führen Sie Folgendes aus:

node echo.js HOME PWD NOT_DEFINED

Das Ergebnis wird in etwa der folgenden Abbildung entsprechen:

[secondary_label Output] 
/home/sammy
/home/sammy/first-program
undefined

Die ersten beiden Zeilen werden wie erwartet ausgegeben, die letzte Zeile ist jedoch undefiniert. In JavaScript bedeutet ein undefinierter Wert, dass einer Variablen oder Eigenschaft kein Wert zugewiesen wurde. Da NOT_DEFINED keine gültige Umgebungsvariable ist, wird sie als undefiniert angezeigt.

Wenn das vom Benutzer angegebene Befehlszeilenargument in der Umgebung nicht gefunden wird, wäre es für den Benutzer hilfreicher, eine Fehlermeldung zu sehen.

Öffnen Sie echo.js zum Bearbeiten:

nano echo.js

Bearbeiten Sie die Datei echo.js so, dass sie folgenden Code enthält:

const args = process.argv.slice(2);
args.forEach(arg => {
let envVar = process.env[arg];
if (envVar === undefined) {
console.error(`Could not find "${arg}" in environment`);
} else {
console.log(envVar);
}
});

Hier haben Sie die an forEach übergebene Callback-Funktion wie folgt modifiziert:

1. Den Wert der Befehlszeilenargumente in der Umgebung abrufen und in einer Umgebungsvariablen speichern.
2. Prüfen Sie, ob der Wert der Umgebungsvariablen undefiniert ist.
3. Falls envVar nicht definiert ist, geben wir eine hilfreiche Meldung aus, die darauf hinweist, dass sie nicht gefunden wurde.
4. Wenn die Umgebungsvariable gefunden wird, geben wir ihren Wert aus.

Führen Sie nun den folgenden Befehl erneut aus:

node echo.js HOME PWD NOT_DEFINED

Diesmal lautet die Ausgabe:

[secondary_label Output] 
/home/sammy
/home/sammy/first-program
Could not find "NOT_DEFINED" in environment

Wenn Sie nun ein Befehlszeilenargument angeben, das keine Umgebungsvariable ist, erhalten Sie eine eindeutige Fehlermeldung.

Ergebnis

Ihr erstes Programm zeigte “Hello World” auf dem Bildschirm an, und jetzt haben Sie ein Node.js-Befehlszeilentool geschrieben, das Benutzerargumente liest, um Umgebungsvariablen anzuzeigen.

Wenn Sie das Programm noch weiter optimieren möchten, können Sie sein Verhalten noch weiter anpassen. Beispielsweise könnten Sie die Kommandozeilenargumente vor der Ausgabe überprüfen. Ist ein Argument nicht definiert, können Sie einen Fehler zurückgeben, und der Benutzer erhält nur dann eine Ausgabe, wenn alle Argumente gültige Umgebungsvariablen sind.