Abschnitt 8 · Lektion 1
Der erste Server
Ein Skript startet, tut seine Arbeit und endet. Für eine Seite im Browser reicht das nicht. Wenn jemand sie aufruft, muss auf der anderen Seite schon etwas laufen und zuhören, und zwar auch noch für den nächsten Aufrufer und den danach. Ein Server startet deshalb und wartet dann, bis jemand etwas von ihm will.
Zwei Aufrufe, mehr braucht es nicht
createServer nimmt eine Funktion entgegen und gibt dir ein Server-Objekt zurück. listen legt
diesen Server auf einen Port.
import { createServer } from "node:http";
const server = createServer((req, res) => {
res.end("Guten Tag");
});
server.listen(3000, () => {
console.log("Server hört auf Port 3000");
}); Ein Port ist eine Nummer, unter der ein Programm auf einem Rechner erreichbar ist. Der Rechner hat
eine Adresse, das Programm darauf eine Nummer. Beides zusammen ergibt die Stelle, an die eine
Anfrage geht. Viel mehr Netzwerktheorie brauchst du für diesen Kurs nicht. Im Alltag begegnet dir
davon nur eine Regel. Zwei Programme können nicht gleichzeitig denselben Port belegen, und wenn du
irgendwann EADDRINUSE liest, läuft meistens noch ein alter Serverprozess von vorhin, der den Port
nicht freigegeben hat.
Und das Programm endet nicht. Nach dem listen ist die letzte Zeile abgearbeitet, aber Node bleibt.
Wie in Lektion 1.2 beendet sich Node erst, wenn nichts mehr offen ist. Ein Server, der auf einem
Port hört, ist die offenste Sache, die es gibt. Er wartet, also bleibt das Programm.
Beim ersten Beispiel lässt sich dabei zusehen. Im Reiter Browser steht die Antwort, und sie steht da auch noch, wenn du die Seite neu lädst. Niemand hat den Prozess wieder gestartet, er war die ganze Zeit da. Ein Serverprogramm hört nicht von selbst auf. Deshalb kannst du es anfassen, statt ihm beim Ablaufen zuzusehen.
Die Funktion läuft einmal je Anfrage
Die Funktion, die du an createServer übergibst, wird nicht einmal beim Start aufgerufen. Sie läuft
jedes Mal neu, wenn eine Anfrage hereinkommt. Bei zehn Aufrufern läuft sie zehnmal.
import { createServer } from "node:http";
// Die Variable lebt ausserhalb der Funktion, also ueberlebt sie jede
// einzelne Anfrage. Die Funktion darunter faengt bei jeder neu an.
let anfragen = 0;
const server = createServer((req, res) => {
anfragen = anfragen + 1;
res.end(`Guten Tag. Das war Anfrage Nummer ${anfragen} auf ${req.url}`);
});
server.listen(3000); Sie bekommt zwei Argumente. Die Namen req und res sind Gewohnheit, keine Vorschrift.
req ist alles, was hereinkommt. Welche Methode benutzt wurde, welche Adresse gemeint war und
welche Kopfzeilen mitgeschickt wurden. Ein Objekt zum Lesen, an dem du nichts zu ändern hast. Was
alles darin steckt, kommt in Lektion 8.3.
res ist der Block Papier, auf den die Antwort geschrieben wird, also ein Objekt zum Schreiben.
Darauf kommen Statuscode, Kopfzeilen, der Rumpf mit dem eigentlichen Inhalt und am Ende ein Strich
darunter.
Im Beispiel lässt sich das nachzählen, denn die Zahl steht in der Antwort. Jedes Neuladen der Seite
im Reiter Browser zählt sie um eins hoch. Eine andere Adresse in der Adresszeile, etwa /irgendwas,
zählt einfach weiter, weil es immer dieselbe Funktion ist. Die beiden Befehle
curl -s http://localhost:3000/ und curl -s http://localhost:3000/irgendwas aus der Befehlsleiste
zählen im Terminal mit.
Die Variable anfragen steht dabei außerhalb der Funktion. Was drinnen steht, entsteht bei
jeder Anfrage neu und ist danach weg. Was draußen steht, lebt so lange wie der Server.
Eine Antwort muss abgeschlossen werden
import { createServer } from "node:http";
const server = createServer((req, res) => {
// Hier fehlt res.end(). Die Anfrage kommt an, die Funktion laeuft
// durch, aber niemand schliesst die Antwort ab.
});
server.listen(3000); Die Anfrage kommt an, die Funktion läuft durch. Und dann passiert nichts mehr. Node meldet nichts
und stürzt auch nicht ab. Die Seite im Reiter Browser lädt und hört nicht auf damit, und der
Aufrufer wartet, bis er von sich aus aufgibt. Im Terminal setzt ihm
curl -sS --max-time 3 http://localhost:3000/ eine Frist, und nach drei Sekunden steht dort
Operation timed out. Das ist alles, was ein Aufrufer je erfährt.
Node kann nämlich nicht wissen, ob du fertig bist. Vielleicht willst du noch eine zweite Zeile
schreiben, vielleicht wartest du noch auf eine Datei. Erst res.end() sagt, dass das alles war und
die Antwort losgehen kann.
Diese Sorte Fehler erkennst du in Zukunft am Verhalten. Ein Absturz gibt dir einen Stacktrace, ein
falscher Statuscode gibt dir eine falsche Antwort. Bleibt eine Anfrage dagegen einfach hängen, dann
fehlt auf dem Weg ein res.end(), oder ein Zweig deiner Verzweigung kommt nie dort an. Der Aufrufer
wartet in dem Fall, bis er selbst aufgibt. Bei der Prüfung hier ist nach fünf Sekunden Schluss, bei
curl ohne --max-time nie.
res.end() nimmt übrigens optional den Rumpf gleich mit, wie in den Beispielen oben. Du kannst
stattdessen auch mehrfach res.write() aufrufen und am Ende ein leeres res.end() setzen. Für
kurze Antworten ist die erste Form die übliche.
In der Aufgabe startest du deinen ersten eigenen Server, und er soll jedem antworten, egal unter welcher Adresse.
Zum Mitnehmen
Ein Server läuft, bis man ihn beendet, und seine Funktion läuft einmal je Anfrage. Die Antwort geht erst mit res.end() hinaus, und fehlt der Aufruf, wartet der Aufrufer, bis er aufgibt.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.