Node.JS

node.js lässt sich unter Ubuntu folgendermaßen installieren:

Zunächst einmal sollte man vor der Installation via apt-get (mit Root-Rechten natürlich) das System updaten:

apt-get update
apt-get install g++ curl libssl-dev

Als nächstes gibt es die Möglichkeit via git die Pakete zu Downloaden:

apt-get install git-core
 cd /usr/src
 git clone https://github.com/joyent/node.git
 cd node
git checkout v0.10.32

Alternativ lässt sich das ganze auch via tar downloaden:

wget http://nodejs.org/dist/node-latest.tar.gz
 tar -xzvf node-latest.tar.gz
 cd node-v0.10.32

Bei zukünftigen Downloades kann die Versionsnummer natürlich abweichen.

Kompilieren lässt sich das ganze folgendermaßen:

./configure
 make
 make install

Öffnen lässt sich die Nodekonsole mittels:

/usr/local/bin/node

Für npm (node package manager) analog dazu:

/usr/local/bin/npm

Der npm dient dazu, Module von node.js zu installieren.

Eine Hello-World-Seite lässt sich folgendermaßen auf den Localhost bringen (bis zum Neustart):

var http = require('http');
// Lädt einen Httpserver
 
 
var server = http.createServer(function (request, response) {
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.end("Hello World\n");
});
// Konfiguriert den Httpserver und sendet den Text 'Hello World' an den Server
 
 
server.listen(8000);
// Überträgt den Inhalt an den Port 8000 des localhosts (127.0.0.1)
 
 
console.log("Server running at http://127.0.0.1:8000/");
// Gibt einen Text nach Ausführung in der Konsole aus.

Alternativ zu den Konsolen, lässt sich der Code auch in einer .js-Datei speichern und mit node aufrufen:

node testdatei.js 

Hierbei befindet sich die Testdatei im rootverzeichnis von nodejs oder es wird der relative Dateipfad benötigt.

Node.js bringt von sich aus das Template Jade mit, welches Html-Dateien erzeugen soll, jedoch eine etwas andere, weil verkürzte, Syntax hat als „normales“ HTML. Hier ein Beispielcode:

!!! 5
html
  head
    title my jade template
  body
    h1 Hello #{name}
    ul#books
        li
            a(href="#book-a") Book A
        li
            a(href="#book-b") Book B
  
    p
        | foo bar
        | hello world

    foo = "hello world"
    h1= foo
    
    //comment
    select
        each book, i in books
            option(value=i) Book #{book}

{"name": "Bob"}
{"books": ["A", "B", "C"]}

Dabei wird klar, dass sich in Jade beispielsweise Variablen, Schleifen einfügen lassen, ohne eine zusätzliche Sprache benutzen zu müssen, im Gegensatz zu Html und, dass der Code insgesamt etwas kürzer ist (Im Beispiel bedingt durch Arrays und Schleifen und der generellen Syntax, da kein </head> bzw. kein </body> benötigt wird). Wer jedoch bereits eine Html-Datei hat und diese nicht extra umschreiben möchte, oder einfach keine Zeit hat eine neue Syntax zu lernen, der kann seine Html-Datei problemlos in Node.js einbinden:

var fs         = require('fs'); // objekttyp bspw. 'http' oder 'net'
 
var s =  http.createServer(function(req, res){
 
    //Einbinden der 'test.html'-Datei
    fs.readFile('test.html',function (err, data){
        res.writeHead(200, {'Content-Type': 'text/html','Content-Length':data.length});
        res.write(data);
        res.end();
    });
})
s.listen(8000);

Hierbei ist jedoch zu beachten, dass 'test.html' im Rootverzeichnis des Nodeservers liegt oder man einen relativen Pfad angeben muss.

Manchmal möchte man an einer Seite mit anderen Zusammenarbeiten. Das ganze am besten von zu Hause aus und jeder an seinem eigenen Rechner. Dazu gibt es bei node.js eine Synchronisationsfunktion. Dazu ein kleines Beispiel:

// Asynchrones Lesen
var filesystem = require("fs");
filesystem.readFile("text.txt", "utf8", function(error, data) {
    console.log(data);
});
 
// Synchrones Lesen
var filesystem  = require("fs");
var data = filesystem.readFileSync("text.txt", "utf8");
console.log(data);

Bei der ersten Version wird das ganze Dokument geladen und schließlich am Ende der Textinhalt in der Konsole ausgegeben. Bei der zweiten Variante hingegen wird der Text synchronisierend geladen, so dass die Reihenfolge wie im Script ausgegeben wird.

Um eine Aktualisierung eines Dokumentes, wie dieses etwa beim Etherpad der Fall ist, so benötigt man Socket.io. Socket.io aktualisiert eine Seite automatisch, aber nur, wenn eine Aktualisation notwendig ist.

Installieren lässt sich dies über den Node Package Manager (npm):

npm install socket.io 

// HTTP-Server auf Port 8080
var app = require('http').createServer(serveStaticIndex).listen(8080);
 
// Laden von Socket.io:
//(Gibt für die Demo nur Fehler/Warnungen auf der Konsole aus)
var io = require('socket.io').listen(app).set('log level', 1);
 
// Zugriff auf das Dateisystem (zum Ausliefern der index.html)
var fs = require('fs');
 
// Liefert die Startseite aus
function serveStaticIndex(req, res) {
  var fileStream = fs.createReadStream(__dirname + '/index.html');
      res.writeHead(200);
      fileStream.pipe(res);
}
 
// Socket.io-Events
io.sockets.on('connection', function (socket) { // wartet und reagiert auf Event
  console.log('[socket.io] Ein neuer Client (Browser) hat sich verbunden.\n');
 
  console.log('[socket.io] SENDE "welcome"-Event an den Client.\n');
  socket.emit('welcome', "Hello world");        //löst einen Event aus
                                                // soll Nachricht an alle Clients gesendet werden so muss 
                                                //io.socket.emit() ausgeführt werden
 
  socket.on('user agent', function (data) {
    console.log('[socket.io] EMPFANGE "user agent"-Event vom Client:');
    console.log(data, '\n');
  });
});

Die Konsole des Browsers und der Kommandozeilenausgabe im Terminal zeigen daraufhin die Nachrichten an, die zwischen Client und Server übermittelt werden. Sobald die Seite im Browser aufgerufen wird, erhält der Server darüber eine Benachrichtigung und sendet seinerseits eine Nachricht zurück an den Client, der daraufhin seinen User Agent-String als Beispiel wieder an den Server zurückschickt.

Möchte man also Kommunizieren via Chat (auch Gruppenchat), Online-Spiele (Position der Spieler) oder andere Sachen, die zeitgleich aktualisierte Informationen an mehrere Endnutzer benötigen, programmieren, so bietet sich Socket.io an.

Natürlich kann man sich Module, die man gerne benutzen möchte auch selbst schreiben und einbinden. Dazu werden in einer .js-Datei, die Dinge gespeichert, die übergeben werden sollen, also bpsw. Funktionen und/oder Variablen. Wichtig dabei ist es allerdings, dass man, was man übergeben will, auch exportiert. Dabei gibt es folgende Möglichkeiten:

var hobby = 'sport';
var multiplyBy2= function(n){
    return n*2;
};
 
var multiplyBy10 = function (n){
    return n*10;
};
 
exports.hobby = hobby;
exports.malZehn = multiplyBy10;

Würde man dieses nun einbinden, so wird die Funktion, die hier als multiplyBy10 benannt wurde als malZehn importiert und die Funktion multiplyBy2 wird nicht importiert. Eine Datei namens multiplier.js lässt sich (abhängig vom Dateipfad) folgendermaßen einbinden_

var m = require('./multiplier.js');

Mit dem erzeugten m lassen sich nun der Exportierte Inhalt der multiplier.js-Datei benutzen. Dies lässt sich in der Node-Konsole ganz einfach testen:

m // Enter drücken
 
<hobby : 'sport',           //Ausgabe
 malZehn: [Function]>
//--------------------
 
m.multiplyBy2               // Enter drücken
undefined                   //Ausgabe
//--------------------
 
m.hobby                     // Enter drücken
'sport'                     //Ausgabe

Hierbei sieht man, dass wirklich nur die Exporte auf m anwendbar sind. Weiter fällt auf, dass sich damit auch Assoziative Felder erstellen lassen. Führt man mehrmals hintereinander den require-Befehl auf die gleiche Variable, so fällt auf bspw. mit nem console.log()), dass diese Variable nur einmal und nicht jedesmal überschrieben wird. Eine weitere Möglichkeit, die das Export von oben überschreibt ist Folgende:

module.exports = {
    hobby : hobby,
    malZehn : multiplyBy10,
    test : function(){
        console.log('test');
    }
}

Wäre vorher im Code etwas anderes Exporttiert werden, wie etwa die multiplyBy2-Funktion, so würde module.exports dieses überschreiben, so dass es schließlich nicht mehr, da nicht enthalten, exportiert wird. Dieses lässt sich ebenfalls wie oben mittels Node-Kosole analog testen.