Node.js für Anfänger | Envato Tuts+

() translation by (you can also view the original English article)

Die ereignisgesteuerte Programmierung kann für Anfänger überwältigend sein, was Node.js den Einstieg erschwert. Aber lass dich davon nicht entmutigen. In diesem Artikel werde ich Ihnen einige Grundlagen von Node.js beibringen und erklären, warum es so populär geworden ist.

Einführung

Um Node.js verwenden zu können, müssen Sie zunächst die Unterschiede zwischen Node.js und herkömmlichen serverseitigen Skriptumgebungen verstehen (z.B.: PHP, Python, Ruby usw.).

Asynchrone Programmierung

Node.js verwendet eine Modularchitektur, um die Erstellung komplexer Anwendungen zu vereinfachen.

Die Chancen stehen gut, dass Sie mit der asynchronen Programmierung vertraut sind. es ist schließlich das "A" in Ajax. Jede Funktion in Node.js ist asynchron. Daher wird alles, was normalerweise den Thread blockieren würde, stattdessen im Hintergrund ausgeführt. Dies ist das Wichtigste, was man sich über Node.js merken sollte. Wenn Sie beispielsweise eine Datei im Dateisystem lesen, müssen Sie eine Rückruffunktion angeben, die ausgeführt wird, wenn der Lesevorgang abgeschlossen ist.

Du tust alles!

Node.js ist nur eine Umgebung - das heißt, Sie müssen alles selbst machen. Es gibt keinen Standard-HTTP-Server oder irgendeinen Server für diese Angelegenheit. Dies kann für neue Nutzer überwältigend sein, aber die Auszahlung ist eine leistungsstarke Web-App. Ein Skript behandelt die gesamte Kommunikation mit den Clients. Dies reduziert die Anzahl der von der Anwendung verwendeten Ressourcen erheblich. Hier ist zum Beispiel der Code für eine einfache Node.js-Anwendung:

1	var i, a, b, c, max;
2
3	max = 1000000000;
4
5	var d = Date.now();
6
7	for (i = 0; i < max; i++) {
8	a = 1234 + 5678 + i;
9	b = 1234 * 5678 + i;
10	c = 1234 / 2 + i;
11	}
12
13	console.log(Date.now() - d);

Und hier ist das Äquivalent in PHP geschrieben:

1	$a = null;
2	$b = null;
3	$c = null;
4	$i = null;
5	$max = 1000000000;
6
7	$start = microtime(true);
8
9	for ($i = 0; $i < $max; $i++) {
10	$a = 1234 + 5678 + $i;
11	$b = 1234 * 5678 + $i;
12	$c = 1234 / 2 + $i;
13	}
14
15	var_dump(microtime(true) - $start);

Sehen wir uns nun die Benchmark-Zahlen an. In der folgenden Tabelle sind die Antwortzeiten für diese beiden einfachen Anwendungen in Millisekunden aufgeführt:

Anzahl der Iterationen	Node.js	PHP
100	2.00	0.14
10'000	3.00	10.53
1'000'000	15.00	1119.24
10'000'000	143.00	10621.46
1'000'000'000	11118.00	1036272.19

Ich habe die beiden Apps über die Kommandozeile ausgeführt, so dass kein Server die Ausführung der Apps verzögern würde. Ich habe jeden Test zehn Mal durchgeführt und die Ergebnisse gemittelt. PHP ist mit einer kleineren Anzahl von Iterationen deutlich schneller, aber dieser Vorteil löst sich schnell auf, wenn die Anzahl der Iterationen zunimmt. Wenn alles gesagt und getan ist, ist PHP 93% langsamer als Node.js!

Node.js ist schnell, aber Sie müssen ein paar Dinge lernen, um es richtig zu benutzen.

Modules

Node.js verwendet eine Modularchitektur, um die Erstellung komplexer Anwendungen zu vereinfachen. Module ähneln Bibliotheken in C oder Einheiten in Pascal. Jedes Modul enthält eine Reihe von Funktionen, die sich auf das "Thema" des Moduls beziehen. Zum Beispiel enthält das http-Modul Funktionen, die spezifisch für HTTP sind. Node.js bietet einige Kernmodule, die Ihnen den Zugriff auf Dateien im Dateisystem ermöglichen, HTTP und TCP / UDP-Server erstellen und andere nützliche Funktionen ausführen.

Ein Modul ist einfach; Rufen Sie einfach die require() Funktion auf, wie folgt:

1	var http = require('http');

Node.js ist nur eine Umgebung; Du musst alles selbst machen.

Die Funktion require() gibt den Verweis auf das angegebene Modul zurück. Bei diesem Code wird eine Referenz auf das http Modul in der http Variable gespeichert.

Im obigen Code haben wir den Namen eines Moduls an die Funktion require() übergeben. Dadurch sucht Node im Verzeichnis unserer Anwendung nach dem Ordner node_modules und sucht nach dem http Modul in diesem Ordner. Wenn Node den Ordner node_modules (oder das darin enthaltene http Modul) nicht findet, durchsucht er den globalen Modulcache. Sie können auch eine tatsächliche Datei angeben, indem Sie einen relativen oder absoluten Pfad übergeben:

1	var myModule = require('./myModule.js');

Module sind eingekapselte Codeabschnitte. Der Code innerhalb eines Moduls ist meist privat - das bedeutet, dass die darin definierten Funktionen und Variablen nur von der Innenseite des Moduls aus zugänglich sind. You can, however, expose functions and/or variables to be used outside of the module. To do so, use the exports object and populate its properties and methods with the pieces of code that you want to expose. Betrachten Sie das folgende Modul als Beispiel:

var PI = Math.PI;

exports.area = function (r) {
  return PI * r * r;
};

exports.circumference = function (r) {
  return 2 * PI * r;
};

Dieser Code erstellt eine PI-Variable, auf die nur durch den im Modul enthaltenen Code zugegriffen werden kann. Es ist außerhalb des Moduls nicht zugänglich. Als nächstes werden zwei Funktionen für das exports-Objekt erstellt. Diese Funktionen sind außerhalb des Moduls zugänglich, da sie für das exports-Objekt definiert sind. Dadurch ist PI vollständig vor Störungen von außen geschützt. Sie können also sicher sein, dass sich area() und circumference() immer so verhalten, wie sie sollten (solange ein Wert für den Parameter r angegeben wird).

Globaler Geltungsbereich

Node ist eine JavaScript-Umgebung, die in der V8-JavaScript-Engine von Google ausgeführt wird. Daher sollten wir den Best Practices folgen, die wir für die clientseitige Entwicklung verwenden. Zum Beispiel sollten wir es vermeiden, irgendetwas in den globalen Geltungsbereich zu setzen. Das ist jedoch nicht immer möglich. Der globale Bereich in Node ist GLOBAL (im Gegensatz zum window im Browser), und Sie können problemlos eine globale Funktionsvariable erstellen, indem Sie das Schlüsselwort var wie folgt auslassen:

1	globalVariable = 1;
2	globalFunction = function () { ... };

Wiederum sollten Globals wann immer möglich vermieden werden. Seien Sie also vorsichtig und denken Sie daran, var zu verwenden, wenn Sie eine Variable deklarieren.

Installation

Natürlich müssen wir Node installieren, bevor wir eine App schreiben und ausführen können. Die Installation ist einfach, wenn Sie Windows oder OS X verwenden; Die Website nodejs.org bietet Installationsprogramme für diese Betriebssysteme. Verwenden Sie für Linux einen beliebigen Paketmanager. Öffne dein Terminal und tippe:

1	sudo apt-get update
2	sudo apt-get install node

oder:

1	sudo aptitude update
2	sudo aptitude install node

Node.js ist in Sid-Repositories; Möglicherweise müssen Sie sie zu Ihrer Quellenliste hinzufügen:

1	sudo echo deb http://ftp.us.debian.org/debian/ sid main > /etc/apt/sources.list.d/sid.list

Beachten Sie jedoch, dass die Installation von sid-Paketen auf älteren Systemen das System beschädigen kann. Seien Sie vorsichtig und entfernen Sie /etc/apt/sources.list.d/sid.list, nachdem Sie die Installation von Node abgeschlossen haben.

Installieren neuer Module

Node.js hat einen Paketmanager namens Node Package Manager (NPM). Es wird automatisch mit Node.js installiert und Sie verwenden NPM, um neue Module zu installieren. Um ein Modul zu installieren, öffnen Sie Ihr Terminal / Ihre Befehlszeile, navigieren Sie zum gewünschten Ordner und führen Sie den folgenden Befehl aus:

1	npm install module_name

Es ist egal, welches Betriebssystem Sie haben; Der obige Befehl installiert das von Ihnen angegebene Modul anstelle von module_name.

Die Hallo Welt App

Natürlich wird unser erstes Node.js Skript den Text 'Hello World!' zur Konsole. Erstellen Sie eine Datei mit dem Namen hello.js, und geben Sie den folgenden Code ein:

1	console.log('Hello World!');

Lassen Sie uns nun das Skript ausführen. Öffnen Sie das Terminal / die Befehlszeile, navigieren Sie zu dem Ordner, der hello.js enthält, und führen Sie den folgenden Befehl aus:

1	node hello.js

Du solltest "Hallo Welt!" Sehen in der Konsole angezeigt.

HTTP Server

Kommen wir zu einer fortgeschritteneren Anwendung. es ist nicht so kompliziert wie du vielleicht denkst. Beginnen wir mit dem folgenden Code. Lesen Sie die Kommentare und dann die folgende Erklärung:

// Include http module.
var http = require("http");

// Create the server. Function passed as parameter is called on every request made.
// request variable holds all request parameters
// response variable allows you to do anything with response sent to the client.
http.createServer(function (request, response) {
  // Attach listener on end event.
	// This event is called when client sent all data and is waiting for response.
	request.on("end", function () {
		// Write headers to the response.
		// 200 is HTTP status code (this one means success)
		// Second parameter holds header fields in object
		// We are sending plain text, so Content-Type should be text/plain
		response.writeHead(200, {
			'Content-Type': 'text/plain'
		});
		// Send data and end response.
		response.end('Hello HTTP!');
	});
// Listen on the 8080 port.
}).listen(8080);

Dieser Code ist sehr einfach. Sie können mit dem response.write() mehr Daten an den Client senden. Methode, aber Sie müssen es aufrufen, bevor Sie response.end() aufrufen. Speichern Sie diesen Code als http.js und geben Sie diesen in Ihre Konsole ein:

1	node http.js

Öffne deinen Browser und navigiere zu http://localhost:8080. Sie sollten den Text "Hallo HTTP!" auf der Seite.

Handling URL Parameters

Wie ich bereits erwähnt habe, müssen wir alles selbst in Node erledigen, einschließlich der Analyse von Anforderungsargumenten. Dies ist jedoch ziemlich einfach. Sehen Sie sich den folgenden Code an:

// Include http module, 
var http = require("http"), 
// And url module, which is very helpful in parsing request parameters. 
	url = require("url"); 

// Create the server. 
http.createServer(function (request, response) { 
	// Attach listener on end event. 
	request.on('end', function () { 
		// Parse the request for arguments and store them in _get variable. 
		// This function parses the url from request and returns object representation. 
		var _get = url.parse(request.url, true).query; 
		// Write headers to the response. 
		response.writeHead(200, { 
			'Content-Type': 'text/plain' 
		}); 
		// Send data and end response. 
		response.end('Here is your data: ' + _get['data']); 
	}); 
// Listen on the 8080 port. 
}).listen(8080);

Dieser Code verwendet die parse() - Methode des url Moduls, ein zentrales Node.js-Modul, um die URL der Anfrage in ein Objekt zu konvertieren. Das zurückgegebene Objekt verfügt über eine query, die die Parameter der URL abruft. Speichern Sie diese Datei als get.js und führen Sie sie mit dem folgenden Befehl aus:

1	node get.js

Navigieren Sie dann in Ihrem Browser zu http://localhost:8080/?data=put_some_text_here. Natürlich ändert das Ändern des Wertes des data parameters das Skript nicht.

Dateien lesen und schreiben

Um Dateien in Node zu verwalten, verwenden wir das fs Modul (ein Kernmodul). Wir lesen und schreiben Dateien mit den Methoden fs.readFile() bzw. fs.writeFile(). Ich werde die Argumente nach dem folgenden Code erklären:

// Include http module,
var http = require("http"),
// And mysql module you've just installed.
	fs = require("fs");

// Create the http server.
http.createServer(function (request, response) {
	// Attach listener on end event.
	request.on("end", function () {
		// Read the file.
		fs.readFile("test.txt", 'utf-8', function (error, data) {
			// Write headers.
			response.writeHead(200, {
				'Content-Type': 'text/plain'
			});
			// Increment the number obtained from file.
			data = parseInt(data) + 1;
			// Write incremented number to file.
			fs.writeFile('test.txt', data);
			// End response with some nice message.
			response.end('This page was refreshed ' + data + ' times!');
		});
	});
// Listen on the 8080 port.
}).listen(8080);

Node.js hat einen Paketmanager namens Node Package Manager (NPM). Es wird automatisch mit Node.js installiert

Speichern Sie dies als files.js. Bevor Sie dieses Skript ausführen, erstellen Sie eine Datei namens test.txt im selben Verzeichnis wie files.js.

Dieser Code demonstriert die Methoden fs.readFile() und fs.writeFile(). Jedes Mal, wenn der Server eine Anfrage erhält, liest das Skript eine Nummer aus der Datei, erhöht die Nummer und schreibt die neue Nummer in die Datei. Die Methode fs.readFile() akzeptiert drei Argumente: den Namen der zu lesenden Datei, die erwartete Codierung und die Callback-Funktion.

Das Schreiben in die Datei ist zumindest in diesem Fall viel einfacher. Wir müssen nicht auf Ergebnisse warten, obwohl Sie in einer realen Anwendung nach Fehlern suchen würden. Die Methode fs.writeFile() akzeptiert den Dateinamen und die Daten als Argumente. Es akzeptiert auch das dritte und das vierte Argument (beide sind optional), um die Kodierungs- bzw. Rückruffunktion anzugeben.

Lassen Sie uns nun dieses Skript mit dem folgenden Befehl ausführen:

1	node files.js

Öffnen Sie es im Browser (http://localhost:8080) und aktualisieren Sie es einige Male. Jetzt können Sie denken, dass ein Fehler in dem Code ist, da es scheint, um zwei zu erhöhen. Dies ist kein Fehler. Jedes Mal, wenn Sie diese URL anfordern, werden zwei Anfragen an den Server gesendet. Die erste Anfrage wird automatisch vom Browser gestellt, der favicon.ico anfordert, und natürlich ist die zweite Anfrage für die URL (http://localhost:8080).

Obwohl dieses Verhalten technisch gesehen kein Fehler ist, ist es ein Verhalten, das wir nicht wollen. Wir können dies leicht beheben, indem wir die Anforderungs-URL überprüfen. Hier ist der überarbeitete Code:

// Include http module,
var http = require("http"),
// And mysql module you've just installed.
	fs = require("fs");

// Create the http server.
http.createServer(function (request, response) {
	// Attach listener on end event.
	request.on('end', function () {
		// Check if user requests /
		if (request.url == '/') {
			// Read the file.
			fs.readFile('test.txt', 'utf-8', function (error, data) {
				// Write headers.
				response.writeHead(200, {
					'Content-Type': 'text/plain'
				});
				// Increment the number obtained from file.
				data = parseInt(data) + 1;
				// Write incremented number to file.
				fs.writeFile('test.txt', data);
				// End response with some nice message.
				response.end('This page was refreshed ' + data + ' times!');
			});
		} else {
			// Indicate that requested file was not found.
			response.writeHead(404);
			// And end request without sending any data.
			response.end();
		}
	});
// Listen on the 8080 port.
}).listen(8080);

Teste es jetzt; es sollte wie erwartet funktionieren.

Zugriff auf MySQL-Datenbanken

Die meisten herkömmlichen Server-seitigen Technologien verfügen über eine integrierte Möglichkeit zum Herstellen einer Verbindung mit einer Datenbank und zum Abfragen einer Datenbank. Mit Node.js müssen Sie eine Bibliothek installieren. Für dieses Tutorial habe ich den stable und einfach zu benutzenden node-mysql ausgewählt. Der vollständige Name dieses Moduls lautet mysql@2.0.0-alpha2 (alles nach dem @ ist die Versionsnummer). Öffnen Sie Ihre Konsole, navigieren Sie zu dem Verzeichnis, in dem Sie Ihre Skripts gespeichert haben, und führen Sie den folgenden Befehl aus:

1	npm install mysql@2.0.0-alpha2

Dadurch wird das Modul heruntergeladen und installiert, und es wird auch der Ordner node_modules im aktuellen Verzeichnis erstellt. Nun schauen wir uns an, wie wir das in unserem Code verwenden können; siehe folgendes Beispiel:

// Include http module, 
var http = require('http'), 
// And mysql module you've just installed. 
	mysql = require("mysql"); 
	 
// Create the connection. 
// Data is default to new mysql installation and should be changed according to your configuration. 
var connection = mysql.createConnection({ 
	user: "root", 
	password: "", 
	database: "db_name"
}); 

// Create the http server. 
http.createServer(function (request, response) { 
	// Attach listener on end event. 
	request.on('end', function () { 
		// Query the database. 
		connection.query('SELECT * FROM your_table;', function (error, rows, fields) { 
			response.writeHead(200, { 
				'Content-Type': 'x-application/json' 
			}); 
			// Send data as JSON string. 
			// Rows variable holds the result of the query. 
			response.end(JSON.stringify(rows)); 
		}); 
	}); 
// Listen on the 8080 port. 
}).listen(8080);

Das Abfragen der Datenbank mit dieser Bibliothek ist einfach; Geben Sie einfach die Abfragezeichenfolge und die Rückruffunktion ein. In einer realen Anwendung sollten Sie prüfen, ob error aufgetreten sind (der Fehlerparameter ist nicht undefined, wenn Fehler aufgetreten sind) und die Antwortcodes abhängig vom Erfolg oder Misserfolg der Abfrage senden. Also note that we have set the Content-Type to x-application/json, which is the valid MIME type for JSON. The rows parameter contains the result of the query, and we simply convert the data in rows to a JSON structure using the JSON.stringify() methode.

Speichern Sie diese Datei als mysql.js und führen Sie sie aus (wenn Sie MySQL installiert haben):

1	node mysql.js

Navigieren Sie in Ihrem Browser zu http://localhost:8080, und Sie sollten aufgefordert werden, die JSON-formatierte Datei herunterzuladen.

Fazit

Jede Funktion in Node.js ist asynchron.

Node.js erfordert zusätzliche Arbeit, aber die Auszahlung einer schnellen und robusten Anwendung lohnt sich. Wenn Sie nicht alles auf der untersten Ebene tun möchten, können Sie immer ein Framework auswählen, z. B. >Express, um die Entwicklung von Anwendungen zu erleichtern.

Node.js ist eine vielversprechende Technologie und eine ausgezeichnete Wahl für eine Hochlastanwendung. Es wurde von Unternehmen wie Microsoft, eBay und Yahoo bewiesen. Wenn Sie unsicher sind, ob Sie Ihre Website/Anwendung hosten möchten, können Sie immer eine günstige VPS-Lösung oder verschiedene cloudbasierte Dienste wie Microsoft Azure und Amazon EC2 verwenden. Beide Dienste bieten skalierbare Umgebungen zu einem vernünftigen Preis.

Vergiss nicht zu kommentieren, wenn du irgendwelche Fragen hast!