Node.js für Anfänger

Die ereignisgesteuerte Programmierung für Node.js kann für Anfänger schwierig sein, aber dies bedeutet nicht, dass es schwierig ist, loszulegen. In diesem Artikel wird die Grundlagen von Node.js vorgestellt und erklärt, warum er beliebt ist.

Einführung

Um mit node.js zu beginnen, müssen Sie zunächst den Unterschied zwischen node.js und herkömmlichen serverseitigen Skriptumgebungen wie PHP, Python oder Ruby verstehen.

Asynchrone Programmierung

Sie sind wahrscheinlich mit einer asynchronen Programmierung vertraut. Jede Funktion im Knoten ist asynchron. Daher werden alle Vorgänge, die normalerweise Threads blockieren, im Hintergrund mit Versprechen ausgeführt. Dies ist das Wichtigste am Knoten. Wenn Sie beispielsweise eine Datei in einem Dateisystem lesen, wird eine asynchrone Funktion verwendet.

Wenn Sie eine Version von Knotenfunktionen verwenden, verwenden Sie Callback -Funktionen, die vor dem Erscheinungsbild des Versprechens entworfen wurden. Die meisten Knotenfunktionen haben jetzt versprochene Äquivalente. Daher ist es am besten, die hier verwendete Rückruffunktion in ein versprochenes Äquivalent umzuwandeln und die Syntax zu vergleichen.

Steuern Sie den gesamten Prozess

Mit dem Knoten muss man selbst viel Arbeit erledigen. Beispielsweise sind HTTP -Module sehr optimiert und halten sich nicht an bestimmte Stile. Dies mag für Anfänger überwältigend sein, aber der Vorteil ist die Fähigkeit, Hochleistungs-Webanwendungen zu erstellen (obwohl die Leistung von JavaScript weitgehend auf die v8-optimierte Engine zurückzuführen ist). Ein Skript kümmert sich um alle Kommunikation mit allen Kunden. Dies reduziert die Menge an Ressourcen, die die Anwendung verwendet, erheblich. Beispielsweise finden Sie hier ein einfacher Node.js -Anwendungscode:

 const i, a, b, c, max;
max = 1000000000;
var d = date.now ();
für (i = 0; i <max i a="1234" b="1234" c="1234" console.log d><p> Hier ist der äquivalente Code in PHP:</p>
<pre class="brush:php;toolbar:false"> $ a = null;
$ B = NULL;
$ c = null;
$ i = null;
$ max = 100000000;

$ start = microtime (true);

für ($ i = 0; $ i <p> Schauen wir uns nun die Benchmark -Daten an. In der folgenden Tabelle werden die Antwortzeiten in Millisekunden für diese beiden einfachen Anwendungen aufgeführt:</p><pre class="brush:php;toolbar:false"> const http = required ('http');

HTTP -Variable.

Im obigen Code übergeben wir den Namen des Moduls an das Exportobjekt und füllen seine Eigenschaften und Methoden mit dem zu entlarenden Code -Snippet aus. Betrachten Sie das folgende Modulbeispiel:

 exports.area = function (r) {
  return math.pi * r ** 2;
};

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

Dieser Code erstellt ein Exportobjekt. Diese Funktionen können außerhalb des Moduls zugegriffen werden, da sie auf dem PI definiert sind und vollständig vor externen Interferenzen geschützt sind. Sie können also sicher sein, dass Circuitence () immer wie erwartet funktioniert (einfach einen Wert für das Schlüsselwort importieren):

 // Datei
MyModule aus "./mymodule.js" importieren "
// Knoten integriert in/paket import http aus "http"

In einem Browser kann ESM nur mit relativen Dateipfaden suchen, wie oben gezeigt. Im Knoten können Sie jedoch Pfade ohne Knoten übergeben: Präfix.

Die vorherige Methode eignet sich jedoch nur für Standard -Exporte. Wenn Sie benannte Exporte verwenden (dazu später mehr), müssen Sie eine etwas andere Syntax verwenden.

 Importieren {exporton, exporttwo} aus "./mymodule.js" "

Verwenden Sie zum Exportieren von Inhalten das Schlüsselwort für exportieren. Der Export wird für benannte Exporte verwendet, und der Exportabschluss wird für Standard -Exporte verwendet. Mit dem Namen Export können Sie unterschiedliche Inhalte exportieren und nur eine davon in verschiedenen Modulen verwenden, indem Sie die obige Importsyntax haben. Wenn Sie nur einen Inhalt exportieren, ist es standardmäßig einfacher zu exportieren.

 // Name Exportfunktion exportone () {
    ...
}
Exportfunktion exporttwo () {
    ...
}
// Standard -Export -Standardfunktion defaultFunction () {
    ...
}

Im Rest dieses Tutorials werden wir ESM verwenden.

Globaler Umfang

Node ist eine JavaScript -Umgebung, die in der V8 JavaScript -Engine von Google ausgeführt wird. Daher sollten wir den Best Practices befolgen, die wir in der Kundenentwicklung verwenden. Zum Beispiel sollten wir vermeiden, etwas in den globalen Bereich zu stecken. Dies ist jedoch nicht immer möglich. Der globale Umfang im Knoten ist (Fenster im Browser), und Sie können problemlos globale Variablen einer Funktion erstellen, indem Sie VaR bei der Erklärung von Variablen weglassen.

Installieren

Natürlich müssen wir den Knoten installieren, bevor wir die Anwendung schreiben und ausführen. Wenn Sie Windows oder MacOS verwenden, ist die Installation sehr einfach. Verwenden Sie für Linux einen beliebigen Paketmanager. Wenn Sie beispielsweise eine Verteilung verwenden, die die APT unterstützt, öffnen Sie ein Terminal und Typ:

 sudo apt-Get-Update
sudo apt-Get-Knoten installieren

oder:

 Sudo Aptitude Update
sudo fähig installieren Knoten

Node.js befindet sich im SID -Repository.

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

Beachten Sie jedoch, dass die Installation des SID -Pakets auf älteren Systemen Ihr System beschädigen kann. Seien Sie vorsichtig und löschen Sie Module_Name.

Hallo Welt -App

Natürlich wird unser erstes Node.js -Skript den Text "Hello World!" Drucken.

HTTP -Server

Lassen Sie uns eine fortgeschrittenere Anwendung haben. Beginnen wir mit dem folgenden Code. Lesen Sie die Kommentare und lesen Sie dann die Erklärung unten:

 // enthält ein HTTP -Modul.
Import {createServer} aus "http"

// Erstellen Sie einen Server. Die als Parameter übergebene Funktion wird jedes Mal aufgerufen, wenn die Anforderung gestellt wird.
// Die Anforderungsvariable speichert alle Anforderungsparameter // Mit der Antwortvariablen können Sie alle an den Client gesendeten Antwort auf die Antwort ausführen.
createServer (Funktion (Anfrage, Antwort) {
    // Befestigen Sie den Hörer am Ende.
    // Dieses Ereignis wird aufgerufen, wenn der Client alle Daten sendet und auf eine Antwort wartet.
    Request.on ("End", function () {
        // Schreiben Sie den Header zur Antwort.
        // 200 ist der HTTP -Statuscode (dieser Code zeigt den Erfolg an)
        // Der zweite Parameter speichert das Kopfzeilenfeld im Objekt // Wir senden einen einfachen Text
        Antwort.WriteHead (200, {
            'Inhaltstyp': 'Text/Ebene'
        });
        // Daten senden und die Antwort beenden.
        Antwort.end ('Hallo Http!');
    });
// Port 8080 anhören.
}). Hören (8080);

Dieser Code ist sehr einfach. Sie können mehr Daten an den Client senden, indem Sie response.end () verwenden. Speichern Sie diesen Code als http.js und geben Sie den folgenden Befehl in die Konsole ein:

 Knoten http.js

Öffnen Sie den Browser und navigieren Sie zu https://www.php.cn/link/7232a90ea7d391905f9ee07bcc7c5967 . Sie sollten den Text Hallo HTTP auf der Seite sehen.

Prozess -URL -Parameter

Wie bereits erwähnt, müssen wir alle Arbeiten im Knoten selbst erledigen, einschließlich der Parsen der Anfrageparameter. Dies ist jedoch ganz einfach. Schauen Sie sich den folgenden Code an:

 // CreateServer einschließen
Import {createServer} aus "http"
// und URL -Module, die bei der Parsen von Anforderungen Parametern sehr nützlich sind.
url = erfordern ("url");

// Erstellen Sie einen Server.
createServer (Funktion (Anfrage, Antwort) {
    // Befestigen Sie den Hörer am Ende.
    request.on ('end', function () {
        // Anforderungsparameter analysieren und in der _get -Variablen speichern.
        // Diese Funktion analysiert die URL aus der Anforderung und gibt die Objektdarstellung zurück.
        var _get = url.parse (request.url, true) .query;
        // Schreiben Sie den Header zur Antwort.
        Antwort.WriteHead (200, {
            'Inhaltstyp': 'Text/Ebene'
        });
        // Daten senden und die Antwort beenden.
        Antwort.end ('Hier sind Ihre Daten:' _get ['Daten']);
    });
// Port 8080 anhören.
}). Hören (8080);

Dieser Code verwendet das Abfrageattribut, das die Parameter der URL abruft. Speichern Sie diese Datei als Get.js und führen Sie sie mit dem folgenden Befehl aus:

 Knoten get.js

Das Navigieren zum Datenparameter unterbricht das Skript nicht.

Dateien lesen und schreiben

Um Dateien im Knoten zu verwalten, verwenden wir das FS -Modul (Kernmodul). Wir verwenden die Fs.WriteFile () -Methode zum Lesen und Schreiben von Dateien. Ich werde die Parameter nach dem folgenden Code erklären:

 // CreateServer einschließen,
Import {createServer} aus "http"
// und fs Funktion import {readFile, writefile} aus "fs"

// Erstellen Sie einen HTTP -Server.
createServer (Funktion (Anfrage, Antwort) {
    // Befestigen Sie den Hörer am Ende.
    Request.on ("End", function () {
        // Lesen Sie die Datei.
        ReadFile ("test.txt", 'utf-8', Funktion (Fehler, Daten) {
            // Schreiben Sie in den Header.
            Antwort.WriteHead (200, {
                'Inhaltstyp': 'Text/Ebene'
            });
            // Inkrementieren Sie die aus der Datei erhaltene Nummer.
            Data = ParseInt (Daten) 1;
            // Inkrementierende Zahlen in die Datei schreiben.
            writeFile ('test.txt', data);
            // Beenden Sie die Antwort mit einigen schönen Nachrichten.
            response.end ('Diese Seite wurde aktualisierte' Daten 'Zeiten!');
        });
    });
// Port 8080 anhören.
}). Hören (8080);

Speichern Sie dies als Dateien.js . Erstellen Sie vor dem Ausführen dieses Skripts eine Datei namens test.txt in demselben Verzeichnis wie Dateien.js .

Dieser Code demonstriert die Methode fs.writeFile (). Jedes Mal, wenn der Server eine Anforderung empfängt, liest das Skript eine Nummer aus der Datei, erhöht diese Nummer und schreibt die neue Nummer in die Datei. Die Methode fs.writeFile () akzeptiert den Dateinamen und die Daten als Parameter. Es akzeptiert auch die dritten und vierten Argumente (beide optional) und geben die Codierungs- und Rückruffunktionen an.

Führen Sie nun dieses Skript mit dem folgenden Befehl aus:

 Node Dateien.js

Öffnen Sie es im Browser unter https://www.php.cn/link/7232a90ea7d391905f9ee07BCC7C5967 und aktualisieren Sie es einige Male. Jetzt denken Sie vielleicht, dass Ihr Code einen Fehler gibt, da er zweimal inkrementiert zu sein scheint. Dies ist kein Fehler. Jedes Mal, wenn diese URL angefordert wird, werden zwei Anfragen an den Server gesendet. Die erste Anfrage wird automatisch vom Browser ausgestellt, der favicon.ico verlangt, und natürlich ist die zweite Anfrage für die URL ( https://www.php.cn/link/7232a90ea7d391905f9ee07bCC7C5967 ).

Auch wenn dieses Verhalten technisch nicht falsch ist, ist es nicht das Verhalten, das wir wollen. Wir können dies einfach beheben, indem wir die Anforderungs -URL überprüfen. Das Folgende ist der geänderte Code:

 // CreateServer einschließen,
Import {createServer} aus "http"
// und fs Funktion import {readFile, writefile} aus "fs"

// Erstellen Sie einen HTTP -Server.
createServer (Funktion (Anfrage, Antwort) {
    // Befestigen Sie den Hörer am Ende.
    request.on ('end', function () {
        // Überprüfen Sie, ob der Benutzer anfordert/
        if (request.url == '/') {
            // Lesen Sie die Datei.
            ReadFile ('test.txt', 'utf-8', Funktion (Fehler, Daten) {
                // Schreiben Sie in den Header.
                Antwort.WriteHead (200, {
                    'Inhaltstyp': 'Text/Ebene'
                });
                // Inkrementieren Sie die aus der Datei erhaltene Nummer.
                Data = ParseInt (Daten) 1;
                // Inkrementierende Zahlen in die Datei schreiben.
                writeFile ('test.txt', data);
                // Beenden Sie die Antwort mit einigen schönen Nachrichten.
                response.end ('Diese Seite wurde aktualisierte' Daten 'Zeiten!');
            });
        } anders {
            // zeigt an, dass die angeforderte Datei nicht gefunden wurde.
            Antwort.WriteHead (404);
            // und beenden Sie die Anfrage, ohne Daten zu senden.
            Antwort.end ();
        }
    });
// Port 8080 anhören.
}). Hören (8080);

Testen Sie es jetzt;

Zugriff auf die MySQL -Datenbank

Die meisten herkömmlichen serverseitigen Technologien verfügen über integrierte Methoden, um die Datenbank herzustellen und abfragen zu können. Mit Node.js müssen Sie eine Bibliothek installieren. In diesem Tutorial habe ich mich für den stabilen und benutzerfreundlichen Knoten-Mysql entschieden. Der vollständige Name dieses Moduls lautet mysql@2.0.0-alpha2 (alle Inhalte nach @ ist Versionsnummer). Öffnen Sie die Konsole, navigieren Sie zum Verzeichnis, in dem Sie die Skripte gespeichert haben, und führen Sie den folgenden Befehl aus:

 NPM Installieren Sie MySQL

Dadurch wird das Modul heruntergeladen und installiert. Er erstellt auch den Ordner node_modules im aktuellen Verzeichnis. Lassen Sie uns nun sehen, wie Sie es in Ihrem Code verwenden.

 // enthält ein HTTP -Modul,
Import {createServer} aus "http"
// und das MySQL -Modul, das Sie gerade installiert haben.
Import * als MySQL von "MySQL"

// eine Verbindung erstellen.
// Die Daten stammen aus der neuen MySQL -Installation und sollten entsprechend Ihrer Konfiguration geändert werden.
const Connection = mysql.createConnection ({{
    Benutzer: "root",
    Passwort: "",
    Datenbank: "db_name"
});

// Erstellen Sie einen HTTP -Server.
createServer (Funktion (Anfrage, Antwort) {
    // Befestigen Sie den Hörer am Ende.
    request.on ('end', function () {
        // die Datenbank abfragen.
        Connection.Query ('SELECT * aus Your_table;', Funktion (Fehler, Zeilen, Felder) {
            Antwort.WriteHead (200, {
                'Inhaltstyp': 'X-Anwendung/JSON' '
            });
            // Daten als JSON -Zeichenfolge senden.
            // Zeilenvariable speichert das Ergebnis der Abfrage.
            response.end (json.Stringify (Zeilen));
        });
    });
// Port 8080 anhören.
}). Hören (8080);

Das Abfragen einer Datenbank mit dieser Bibliothek ist einfach die Abfragezeichenfolge und die Rückruffunktion. In einer realen Anwendung sollten Sie auf Fehler prüfen (nicht definiert, wenn ein Fehler auftritt) und den Antwortcode basierend auf dem Erfolg oder Misserfolg der Abfrage senden. Beachten Sie auch, dass wir X-Application/JSON festgelegt haben, was ein gültiger MIME-Typ für JSON ist. Verwenden Sie JSON.stringify() um Zeilen in die JSON -Struktur umzuwandeln.

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

 Node mysql.js

Navigieren Sie in Ihrem Browser zu https://www.php.cn/link/7232A90EA7D391905F9EE07BCC7C5967 , und Sie sollten eine Aufforderung zum Herunterladen der JSON -Formatdatei erhalten.

abschließend

Node.js erfordert zusätzliche Arbeit, aber die Belohnungen einer schnellen und leistungsstarken Anwendung sind es wert. Wenn Sie nicht die gesamte Arbeit auf der niedrigsten Ebene erledigen möchten, können Sie jederzeit ein Framework (z. B. Express) auswählen, um die Entwicklung Ihrer Anwendung zu vereinfachen.

Node.js ist eine vielversprechende Technologie und eine ausgezeichnete Wahl für Hochlastanwendungen. Unternehmen wie Microsoft, eBay und Yahoo haben dies bewiesen. Wenn Sie sich nicht sicher sind, dass Sie Ihre Website oder Anwendung hosten, können Sie jederzeit eine billige VPS-Lösung oder eine Vielzahl von Cloud-basierten Diensten wie Microsoft Azure und Amazon EC2 verwenden. Beide Dienstleistungen bieten skalierbare Umgebungen zu angemessenen Preisen.

Das obige ist der detaillierte Inhalt vonNode.js für Anfänger. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!