Node.js GET/POST-Anfragen

In vielen Szenarien muss unser Server mit dem Browser des Benutzers interagieren, beispielsweise bei Formularübermittlungen.

Formularübermittlungen an den Server verwenden im Allgemeinen GET/POST-Anfragen.

In diesem Kapitel stellen wir Node.js GET/POST-Anfragen vor.

Abrufen des GET-Anfrageinhalts

Da GET-Anfragen direkt im Pfad eingebettet sind, ist die URL der vollständige Anforderungspfad, einschließlich des?Teils nach `?`, sodass Sie den Inhalt danach als GET-Anfrageparameter parsen können.

In Node.js können Sie den URL-Konstruktor verwenden, um die Anfrage-URL zu parsen.

Die URL ist ein Standardwerkzeug in Node.js zum Parsen und Bearbeiten von URLs. Sie bietet eine praktische Schnittstelle, um auf verschiedene Komponenten einer URL zuzugreifen und sie zu ändern, wie Protokoll, Hostname, Pfad, Abfrageparameter usw.

Beispiel

const http = require('http'); const util = require('util'); http.createServer((req, res) => { res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' }); //Verwenden Sie den URL-Konstruktor, um die Anfrage-URL zu parsen. const myUrl = new URL(req.url, `http://${req.headers.host}`); //Geben Sie die verschiedenen Teile der URL aus. res.end(util.inspect({ href: myUrl.href, origin: myUrl.origin, protocol: myUrl.protocol, host: myUrl.host, hostname: myUrl.hostname, port: myUrl.port, pathname: myUrl.pathname, search: myUrl.search, searchParams: Object.fromEntries(myUrl.searchParams) //Konvertieren Sie searchParams in ein einfaches Objekt. })); }).listen(3000); console.log("Server läuft unter http://localhost:3000");

Im Browser aufrufenhttp://localhost:3000/user?name=Example&url=www.example.comDann das zurückgegebene Ergebnis anzeigen:

URL-Parameter abrufen

Wir können die Methode url.parse verwenden, um die Parameter in der URL zu parsen. Der Code lautet wie folgt:

Beispiel

const http = require('http'); http.createServer((req, res) => { res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' }); //Verwenden Sie den URL-Konstruktor, um die Anfrage-URL zu parsen. const myUrl = new URL(req.url, `http://${req.headers.host}`); //Abfrageparameter abrufen const name = myUrl.searchParams.get("name"); const siteUrl = myUrl.searchParams.get("url"); res.write("Website-Name:" + (name || "Nicht angegeben")); res.write("\n"); res.write("Website-URL:" + (siteUrl || "Nicht angegeben")); res.end(); }).listen(3000); console.log("Server läuft unter http://localhost:3000");

Im Browser aufrufenhttp://localhost:3000/user?name=Example&url=www.example.comDann das zurückgegebene Ergebnis anzeigen:

URL-Objekt

Im Folgenden finden Sie die Eigenschaften und Methoden des URL-Objekts:

Eigenschaft/MethodeBeschreibungBeispielausgabe
hrefDer vollständige URL-String"http://example.com:8080/path?foo=bar#section"
originDer Ursprung der URL, einschließlich Protokoll, Hostname und Portnummer (falls vorhanden)"http://example.com:8080"
protocolDer Protokollteil der URL, gefolgt von:"http:"
hostHostname und Portnummer"example.com:8080"
hostnameHostname, ohne Portnummer"example.com"
portPortnummer (falls angegeben)"8080"
pathnameDer Pfadname-Teil"/path"
searchDer Query-String-Teil, einschließlich des führenden?"?foo=bar&hello=world"
searchParamsURLSearchParamsEin Objekt zur Manipulation von Query-Parametern{ foo: 'bar', hello: 'world' }
hashDer Ankerteil, der#"#section"
MethodeBeschreibungBeispielcodeBeispielausgabe
get(name)Ruft den Wert des Query-Parameters mit dem angegebenen Namen abmyUrl.searchParams.get("foo")"bar"
append(name, value)Hängt einen neuen Parameter an den Query-String anmyUrl.searchParams.append("newKey", "newValue")?foo=bar&newKey=newValue
set(name, value)Setzt den Parameter mit dem angegebenen Namen im Query-String (aktualisiert, falls bereits vorhanden)myUrl.searchParams.set("foo", "newBar")?foo=newBar
delete(name)Der Query-Parameter mit dem angegebenen NamenmyUrl.searchParams.delete("foo")?hello=world
has(name)Ermitteln, ob ein Parameter mit dem angegebenen Namen im Query-String vorhanden istmyUrl.searchParams.has("foo")trueoderfalse
forEach(callback)Über die Schlüssel-Wert-Paare der Query-Parameter iterieren und eine Callback-Funktion ausführenmyUrl.searchParams.forEach((v, k) => console.log(k, v))Ausgabe von Schlüssel-Wert-Paaren
toString()Die Query-Parameter in eine String-Form umwandeln, geeignet zum Neuaufbau einer URLmyUrl.searchParams.toString()"foo=bar&hello=world"

Beispiel

const myUrl = new URL("http://example.com/path?foo=bar&hello=world");

console.log(myUrl.pathname);            // Ausgabe: /path
console.log(myUrl.searchParams.get("foo")); // Ausgabe: bar

myUrl.searchParams.append("newKey", "newValue");
console.log(myUrl.href);               // Ausgabe: http://example.com/path?foo=bar&hello=world&newKey=newValue

Abrufen des Inhalts einer POST-Anfrage

In Node.js erfordert die Verarbeitung von POST-Anfragen normalerweise das Empfangen von Daten aus dem Request-Body über das http-Modul. Im Gegensatz zu GET-Anfragen sind POST-Anfragedaten nicht in der URL enthalten, sondern werden als Request-Body gesendet. Wenn Sie daher POST-Daten in Node.js empfangen, müssen Sie auf dasRequestdes Request-ObjektsdataundendEreignis.

  • Hören Sie auf dasdataEreignis: Wenn ein Datenblock am Server eintrifft,dataDas Ereignis wird ausgelöst, und der Datenblock wird als Parameter an die Callback-Funktion übergeben.
  • Hören Sie auf dasendEreignis: Wenn der gesamte Request-Body empfangen wurde,endDas Ereignis wird ausgelöst, und an diesem Punkt können Sie die vollständigen POST-Daten verarbeiten.
Der folgende Code zeigt, wie das http-Modul in Node.js verwendet wird, um POST-Anfragen zu verarbeiten:

Beispiel

const http = require('http');

// HTTP-Server erstellen
http.createServer((req, res) => {
    // Prüfen, ob die Anfragemethode POST ist
    if (req.method === 'POST') {
        let body = '';

        // Auf das data-Ereignis lauschen, Daten in Blöcken empfangen
        req.on('data', (chunk) => {
            body += chunk; // Empfangene Datenblöcke ansammeln
        });

        // Auf das end-Ereignis lauschen, Datenempfang ist abgeschlossen
        req.on('end', () => {
            // Empfangene POST-Daten ausgeben
            console.log('Empfangene POST-Daten:', body);

            // Antwort-Header und Inhalt setzen
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end('POST-Daten erfolgreich empfangen!');
        });

    } else {
        // Umgang mit Nicht-POST-Anfragen
        res.writeHead(405, { 'Content-Type': 'text/plain' });
        res.end('Nur POST-Anfragen werden unterstützt.');
    }

}).listen(3000, () => {
    console.log('Server läuft unter http://localhost:3000');
});

Code-Erklärung:

  1. Request-Methode ermitteln: Verwenden Siereq.method === 'POST'um festzustellen, ob der Anfragetyp POST ist.
  2. Daten empfangen: Inreq.on('data')dem Ereignis, sammeln Sie Datenblöcke, um den vollständigen Datenkörper zu bilden.
  3. Empfang abschließen: Inreq.on('end')dem Ereignis, verarbeiten Sie die vollständigen POST-Daten.
  4. Dem Client antworten: Nach Abschluss des Datenempfangs und der Verarbeitung senden Sie eine Antwort an den Client.

Sie können den curl-Befehl verwenden, um POST-Anfragen zu testen:

curl -X POST -d "name=example&age=25" http://localhost:3000

Umgang mit JSON-Daten

Wenn die POST-Anfrage JSON-Daten sendet, können Siereq.on('end')die empfangenen Daten in ein Objekt parsen:

req.on('end', () => {
    const parsedData = JSON.parse(body); // 将 JSON 字符串解析为对象
    console.log('Received JSON data:', parsedData);
    res.end('JSON data received successfully!');
});

querystring-Modul

Das querystring-Modul wird verwendet, um URL-Abfragezeichenfolgen und POST-Anfragedaten zu verarbeiten.

Für als application/x-www-form-urlencoded codierte POST-Anfragedaten kann das querystring-Modul helfen, den Anfrage-Body zu parsen und ihn in ein JavaScript-Objekt umzuwandeln, um einfachen Zugriff und einfache Bearbeitung zu ermöglichen.

Angenommen, die vom Client gesendeten POST-Anfragedaten haben das Formatapplication/x-www-form-urlencoded(z. B. Formularübermittlung), und die Daten sind ähnlich wiename=example&age=25Nach dem Empfang der Daten können Siequerystring.parseMethode verwenden, um die Daten in ein Objekt zu parsen.

Erläuterung der grundlegenden Syntaxstruktur

var http = require('http'); var querystring = require('querystring'); var util = require('util'); http.createServer(function(req, res){ //Definiere eine post-Variable, um die Request-Body-Informationen vorübergehend zu speichern. var post = ''; //Durch die data-Event-Listener-Funktion von req werden bei Empfang von Request-Body-Daten diese in der post-Variable akkumuliert. req.on('data', function(chunk){ post += chunk; }); //Nachdem das end-Ereignis ausgelöst wurde, verwende querystring.parse, um post in das tatsächliche POST-Anfrageformat zu parsen, und gib es dann an den Client zurück. req.on('end', function(){ post = querystring.parse(post); res.end(util.inspect(post)); }); }).listen(3000);

Das folgende Beispielformular übermittelt per POST und gibt Daten aus:

Beispiel

var http = require('http'); var querystring = require('querystring'); var postHTML = '<html><head><meta charset="utf-8"><title>Beispiel-Tutorial Node.js Beispiel</title></head>' + '<body>' + '<form method="post">' + 'Website-Name: <input name="name"><br>' + 'Website-URL: <input name="url"><br>' + '<input type="submit">' + '</form>' + '</body></html>'; http.createServer(function (req, res) { var body = ""; req.on('data', function (chunk) { body += chunk; }); req.on('end', function () { //Parameter parsen body = querystring.parse(body); //Antwort-Header-Informationen und Kodierung setzen res.writeHead(200, {'Content-Type': 'text/html; charset=utf8'}); if(body.name && body.url) { //Die übermittelten Daten ausgeben res.write("Website-Name:" + body.name); res.write("<br>"); res.write("Website-URL:" + body.url); } else { //Das Formular ausgeben res.write(postHTML); } res.end(); }); }).listen(3000);

GIF-Demo des Ausführungsergebnisses:

Andere Erweiterungen