/ Tutorials / Von

Node.js Beginner Guide

Dieser Artikel richtet sich an alle, die mit Node beginnen möchten, aber noch nicht wirklich viel über Node wissen. Du hast Node bestimmt schon gegoogelt und vielleicht festgestellt, dass viele Tutorials oder Artikel zu advanced sind oder die wirklichen Basics auslassen.

Das liegt auch daran, dass Node sich seit seinem Erscheinen rapide entwickelt hat. Gerade für Beginner ist es deswegen schwer, die guten und aktuellen Informationen für den Start mit Node zu finden. Vielleicht hast du Node auch gerade erst heruntergeladen und fragst dich: was stelle ich jetzt damit an? Dann ist das hier dein Artikel. Was der Artikel nicht ist, ist eine komplette Einführung in Node, er soll mehr ein Startpunkt für deine ersten Schritte mit Node sein und dir aufzeigen was Node auszeichnet.

Was ist Node.js?

Node.js ist eine noch relative junge und spannende JavaScript Runtime für die Entwicklung von Webanwendungen und Anwendungsservern. Darüber hinaus kann Node.js auch für generelle Programmierungs Zwecke eingesetzt werden. Du kannst mit Node alles bauen, von einfachen Command-Line Tools bis hin zu dynamischen HTTP-Servern.

Es war für lange Zeit ein unerfüllter Traum für das Web, dieselbe Programmiersprache auf Server- und Client-Seite zu betreiben. Auch gerade deswegen hat Node in kurzer Zeit so viel an Popularität gewonnen und spielt heute eine bedeutende Rolle im Development. Viele Firmen, darunter auch große Namen wie PayPal oder ebay, haben Teile ihrer Services auf Node.js umgestellt. Die Vorzüge von Node sind unter anderem die extreme Skalierbarkeit und seine Schnelligkeit im Ausführen von I/O Bound Operations.

Das Managen von Input und Output bei Systemen, die über ein Netzwerk kommunizieren, stellt ein eher schwieriges Problem dar. Dazu gehören alle Wege, die Daten im Netzwerk nehmen, read- und write-Vorgänge aus dem Netzwerk auf Festplattenspeicher und vieles mehr. Du kannst dir bestimmt vorstellen, dass so etwas clever geplant sein muss, damit es schnell geht. Node löst dieses Problem sehr gut mit einer ausgetüftelten Kombination von serverseitigem JavaScript-Code, asynchroner Programmierung, anonymen JavaScript Funktionen und einer komplett Ereignis-basierten Architektur.

Das Konzept von Node baut auf der bekannten und super schnellen JavaScript Engine V8 aus Googles Chrome Browser auf. Wichtig für dein Verständnis ist, dass Node selbst keinen Webserver darstellt. Node funktioniert nicht wie ein Apache-Server auf deinem Ubuntu und es gibt auch kein Config-File, welches auf deine HTML-Files verweist. Wenn du Node als HTTP-Server einsetzen willst, musst du dir deinen Server selbst schreiben. Wie du deinen eigenen HTTP-Server schreibst, ist auch das erste, was du in der Node Documentation gezeigt bekommst.

Dank der eingebauten Libraries von Node ist das Coden eines simplen Servers nicht viel Arbeit. Node ist mit vielen nützlichen Build-In Modulen ausgestattet, du musst also nicht jede Kleinigkeit “from scratch” schreiben. Der Gedanke hinter Node war, asynchrone I/O Vorgänge einfacher und bequemer zu machen. Im Prinzip ist Node also nicht nur eine Runtime Environment, sondern auch eine Library. Oder kurz und knapp gesagt: Node.js ist server-side JavaScript.

Node.js installiert, und jetzt?

Nachdem du Node installiert hast, steht dir das Node Command-Line-Interface zur Verfügung. Das Node-CLI kannst du auf zwei verschiedene Arten nutzen, ich stelle dir einmal beide vor.

Der erste Weg ist über das Node REPL-Terminal (read-eval-print-loop), wo du puren Javascript-Code interaktiv ausführen kannst.

Wie du im obigen Beispiel sehen kannst, führt Node den eingegebenen JavaScript Code „console.log(“Hello from gridscale”);“ direkt aus und zeigt dir das Ergebnis an. Node liefert unsere Log-Message und einen Return-Wert vom Typ “undefined” zurück. Für jedes Kommando wird immer ein Return-Wert zurückgeliefert. In unserem Fall wird jedoch kein Wert zurückgeliefert, da console.log nichts returned. Mit dem Befehl exit verlässt du den Prozess wieder.

Der zweite Weg ist, eine JavaScript Datei im Node Terminal auszuführen.
Das ist der gewöhnliche Weg wie du Node benutzt.

Du erstellst einfach eine JavaScript Datei und schreibst deinen Code mit einem Texteditor deiner Wahl, z.B. Atom, in die Datei. Anschließend führst du die Datei mit dem Befehl

node [Dateiname].js

im Terminal aus. In diesem Beispiel habe ich die gleiche console.log Message wie oben in eine Datei mit dem Namen sample.js geschrieben und in meinem Terminal-Fenster ausgeführt:

Node führt den JavaScript Code aus und printed die Log-Message in die Shell. Node macht im Prinzip das gleiche, was dein Browser beim Ausführen von JavaScript tut, nur das der Output Stream nicht in deiner Browser-Konsole landet.

Node.js Modules

Node kommt mit vielen Built-In Modulen, von denen du nach der Installation Gebrauch machen kannst. Mit diesen Modulen kannst du dir externale Funktionalitäten in deine Node Runtime einbinden, auf die du dann zugreifen kannst. Stell sie dir so ähnlich wie JavaScript Bibliotheken vor.

Wenn ein Modul eingebunden wird, erkennst du das an dem Keyboard require. Um innerhalb deines eigenen Codes auf die functions des mit Node gelieferten HTTP-Modules zugreifen zu können, musst du bspw. folgende Zeile einfügen:

var http = require (“http”)

So würdest du das HTTP-Modul in deinen eigenen Code einfügen, den Inhalt des Moduls übergibst du einer lokalen Variablen (http). Es ist gängig, der Variablen den Namen des Moduls zu vergeben, du könntest hier aber genauso gut auch einen eigenen Namen wählen. Durch die Zuweisung des HTTP-Modules wird die lokale Variable http zu einem Objekt, das alle objektgebundenen Methoden des HTTP-Modules umfasst.

Ebenso ist es möglich, eigene Node Modules zu erstellen, das Einbinden eines eigenes Moduls funktioniert ganz ähnlich wie das oben gezeigte Einbinden eines internen Node Modules.

Hier ein Beispiel:

var http = require (“./meinmodul”)

An die Stelle des Keywords für ein internes Modul, würdest du in die runden Klammer den Pfad zu deinem eigenen Modul angeben. Auf diese Weise kannst du deine index.js übersichtlich halten und bestimmte Funktionsweisen deiner App gruppieren und in eigene Modules auslagern. Die Funktionsweisen, auf die du an anderer Stelle deiner App zurückgreifen willst, musst du innerhalb deiner ausgelagerten Modules exportieren.

So würde ein simples Modul mit einer Hello World Funktion aussehen:

exports.hello_world = function () {
console.log(“Hello World”);
}

Mit Hilfe des exports-Objekts kannst du Funktionen, Klassen und Variablen exportieren, es ist extra für diesen Zweck gedacht und ein spezielles Objekt des Node.js Modulsystems. Das oben gezeigte Modul kannst du unter meinmodul.js abspeichern und dann wie folgt einbinden und die Hello World Funktion aufrufen:

var meinmodul = require (“./meinmodul.js”);
meinmodul.hello_world();

Natürlich ist es möglich, beliebig viele Funktionen und Klassen innerhalb des Moduls für dein exports-Objekt zu exponieren.

Bist du bereit zu starten?

Oder hast du noch Fragen? Lasse dir jetzt dein Konto erstellen oder dich in einem persönlichen Gespräch beraten.

Jetzt starten
Beraten lassen

npm – Node Package Manager

npm ist der Paketmanager für Node.js. Es gibt eine große Community, die nützliche Module veröffentlicht, jeder kann diese Module in seinen eigenen Code einbinden und auch du kannst deine eigenen Module für die npm Community bereitstellen. Npm wird bei deiner Installation von Node bereits mit installiert, tippe das Kommando npm help in dein Terminal, um zu schauen ob npm verfügbar ist.

npm Packages sind unkompliziert zu installieren, du verwendest einfach den Befehl npm install + den Namen des Module-Packages. Wie du ein npm-Paket installierst, steht auch immer auf der jeweiligen npm Seite des Paketes. Zudem ist bei vielen Packages der Sourcecode auf GitHub hinterlegt, hier findest du meistens eine README und ggf. auch Beispiele.

Ein populäres npm-Paket ist Forever, Forever sorgt dafür das dein Node Skript kontinuierlich ausgeführt wird. Auf der GitHub und npm-Site von Forever findest du Anweisungen für die Installation. Forever würdest du bspw. mit folgendem Befehl über deine Shell installieren:

npm install forever -g

(Das -g Flag steht für eine globale Installation)

Solltest du gerade nicht den genauen Namen zur Hand haben, kannst du auch einfach innerhalb deiner Shell nach einem npm-Paket suchen. Nutze dafür den Befehl:

npm search

Der Befehl liefert dir den Namen sowie eine Beschreibung zu allen Treffern zurück.

npm installiert deine Modul-Packages innerhalb deines Projekt-Ordners in das Unterverzeichnis node_modules. Sollte das Modul-Package selbst noch Dependencies besitzen, werden diese ebenfalls in einen Ordner node_modules innerhalb dieses Unterverzeichnisses installiert.

Weitere npm Befehle

Du kannst dir eine Liste aller Module innerhalb deines Projekts ausgeben lassen, nutze hierfür das Kommando:

npm ls

Ein bereits installiertes npm-Package updaten kannst du mit:

npm update [paketname]

Wenn du npm update ohne einen Paketnamen ausführst, werden alle deine Packages auf die letzte Version upgedatet.

npm EACCES-ERRORS vermeiden

Bei der Installation von globalen npm-Paketen (wie z. B. bei unserem Forever Beispiel) kann es zu Berechtigungsfehlern kommen. Diese erkennst du an einer EACCES Error-Message. Bei mir selbst traten auch schon EACCES Errors auf, deswegen möchte ich dir hierfür 2 Lösungsvorschläge an die Hand geben:

Der erste Weg, den Fehler zu vermeiden, ist npm bzw. Node über den Versions Manager nvm zu installieren. Du brauchst dafür nicht deine derzeitigen Versionen von Node und npm vom System zu entfernen.

2. Der zweite Weg ist etwas aufwändiger und wird dir hier veranschaulicht.

File I/O mit Node.js

Das Node.js File System Module ist eines der wichtigsten Module in Node. JavaScript selbst bietet dir keine Funktion um Dateien ein- und auszulesen. Dieses Module bietet dir die nötigen Functions um mit Verzeichnissen und Dateien Sachen anzustellen.

Ich zeige dir jetzt mal ein kleines Beispiel, wie du eine Datei mit Node einliest. Wir nutzen dazu eine Function des File System Module welche sich readFile nennt. Ich habe im Vorfeld eine Textdatei mit dem Namen “beispiel.txt” im selben Verzeichnis angelegt.

Das erste Argument der Funktion verweist auf den Pfad, das zweite Argument gibt die Zeichenkodierung an. Wenn dir die Zeichenkodierung deiner Textdatei nicht bekannt ist, bist du auf der sicheren Seite wenn du UTF-8 angibst, die meisten modernen Systeme benutzen diese Kodierung. Lässt du das Argument Zeichenkodierung aus, wird dir kein String zurückgegeben sondern ein Buffer Objekt. Ein Buffer ist so etwas ähnliches wie ein Array, aber darum musst du dir erstmal keine Gedanken machen. Der folgende Code liest die Textdatei ein und loggt den Inhalt in deine Konsole, sobald du ihn ausführst.

// An dieser Stelle wird das File System Module geladen
var fs = require('fs');

// Den Inhalt der Textdatei in den Speicher einlesen
fs.readFile('beispiel.txt', 'utf8', function (err, content) {

// sollte ein Error auftreten 
// wird der Error ausgeworfen und die App beendet
  if (err) throw err;

console.log('Das ist der Inhalt der Textdatei\n', content);

});

Eine weitere Function des File System Module ist writeFile.
Mit writeFile kannst du eine Datei schreiben:

var fs = require('fs');

// Datei erstellen und Inhalt schreiben
fs.writeFile('karneval.txt', 'Kölle Alaaf', function(err) {


// Bei Fehler ERROR ausgeben, andernfalls Erstellung bestätigen
if (err)
    console.log('Error beim schreiben der Datei:', err);
  else
    console.log('Datei erstellt.');

});

HTTP-Server mit Node.js


var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello, World!\n');
}).listen(8080, '127.0.0.1');

console.log('Server running at http://127.0.0.1:8080');

Du hast bestimmt schon eine Ahnung, was in dem Code passiert, oder?
Du siehst einen sehr einfach gestrickten HTTP-Server in Node. Lass uns das Ganze mal ein wenig genauer analysieren… Was in der ersten Zeile passiert, haben wir ja oben bereits geklärt. An dem require erkennst du, dass das HTTP Module geladen wird.
Danach rufen wir die Funktion createServer auf, eine der vielen Funktionen die das HTTP Module liefert. Anschließend übergeben wir die createServer Funktion an eine anonyme Funktion.

Wenn du den Code bei dir ausführst und http://127.0.0.1:8080 in deinem Browser aufrufst, wirst du von einer “Hello, World!” Nachricht begrüßt. Vielleicht fragst du dich, warum der Node Prozess bestehen bleibt, nachdem du die Datei ausführst? Der Grund dafür ist ein aktiver Event-Listener. Die listen Funktion erstellt einen Event-Listener der den HTTP-Server startet und auf eingehende Verbindungen lauscht. Dieser Event-Listener bleibt bestehen und wartet bis du das Programm beendest, führe dazu in deinem Terminal Control+C aus.

Fazit

Ich hoffe, dass ich dir Node.js mit diesem Artikel ein bisschen näher bringen konnte und du ermutigt wurdest, selbst mit Node zu experimentieren. Deiner Fantasie beim Erschaffen von Applications mit Node sind kaum Grenzen gesetzt. Die Core Libraries und die verfügbaren npm Module liefern dir mächtige Puzzlestücke zum Erstellen von komplexen Apps.

Melde dich gerne zu unserem Tutorial Newsletter an und verpasse keine spannenden Developer Themen mehr! Wir schicken dir 1x im Monat die Hot Topics von uns zu 🙂