Abschnitt 10 · Lektion 3
Den Rumpf lesen
req.params und req.query sind sofort da, denn Pfad und Abfrage stehen in der ersten Zeile der
Anfrage. Liest du in einer POST-Route genauso selbstverständlich req.body.name, bekommst du statt
des Namens einen 500. Der Rumpf kommt nach den Kopfzeilen, in Stücken über die Leitung. Wenn die
Route aufgerufen wird, hat ihn noch niemand eingesammelt.
Warum der Rumpf nicht einfach da ist
req ist ein lesbarer Stream wie die aus Abschnitt 7. Er liefert seine Stücke über
data-Ereignisse aus und meldet am Ende end.
import express from "express";
const app = express();
// Ein POST laesst sich nicht in die Adresszeile tippen, deshalb steht
// hier der Befehl dafuer.
app.get("/", (req, res) =>
res.type("text/plain").send(
`curl -s -X POST -H "Content-Type: application/json" -d '{"name":"Mario","jahr":2026}' http://localhost:3000/vonhand\n`
)
);
// Was express.json() im Kern tut, von Hand: der Rumpf kommt in Stuecken,
// jemand muss sie einsammeln und am Ende umwandeln.
app.post("/vonhand", (req, res) => {
let roh = "";
req.on("data", (stueck) => {
roh += stueck;
});
req.on("end", () => {
const daten = JSON.parse(roh);
res.json({ zeichen: roh.length, name: daten.name });
});
});
app.listen(3000); Ein POST lässt sich nicht in die Adresszeile tippen. Im Reiter Browser steht der Befehl deshalb als Text, und in der Befehlsleiste liegt er zum Anklicken.
Acht Zeilen, und mehr macht express.json() im Kern auch nicht. Es sammelt, wartet und wandelt um.
Nur hat diese Fassung alle Fehler, die man dabei machen kann. Sie stürzt bei ungültigem JSON ab,
statt mit 400 zu antworten. Sie nimmt beliebig viel Text entgegen. Sie prüft den Content-Type
nicht. Und sie steht in dieser einen Route statt an einer Stelle für alle. Von Hand schreibt das
deshalb kaum jemand, man meldet einen Parser an.
Die beiden eingebauten Parser
express.json() liest einen JSON-Rumpf, express.urlencoded() ein abgeschicktes HTML-Formular.
Beide meldet man ganz oben als Middleware an. Ab da steht das Ergebnis in req.body.
import express from "express";
const app = express();
// Der Parser gilt nur unter /mit. Unter /ohne kennt niemand den Rumpf.
app.use("/mit", express.json());
app.post("/ohne", (req, res) => res.json({ typ: typeof req.body }));
app.post("/mit", (req, res) =>
res.json({ typ: typeof req.body, name: req.body?.name ?? null })
);
app.get("/", (req, res) =>
res.type("text/plain").send(
`curl -s -X POST -H "Content-Type: application/json" -d '{"name":"Mario"}' http://localhost:3000/ohne\n` +
`curl -s -X POST -H "Content-Type: application/json" -d '{"name":"Mario"}' http://localhost:3000/mit\n`
)
);
app.listen(3000); Beide Pfade liegen in derselben Datei, aber der Parser gilt nur unter /mit. Die beiden Anfragen
schicken denselben Rumpf, und unter /ohne kommt {"typ":"undefined"} zurück. Ohne den Parser ist
req.body also gar nichts, nicht mal ein leeres Objekt.
Der Aufrufer schickt korrekte Daten, und der Server bekommt sie auch. Nur hat sie niemand
eingesammelt. req.body.name wirft dann
TypeError: Cannot read properties of undefined (reading 'name'). Der Server antwortet mit 500, und
der Fehler sieht aus, als läge er in deiner Route.
Ist req.body undefined, fehlt meistens der Parser, oder er steht unter der Route statt darüber.
Einen dritten Grund gibt es noch, und der hängt am Content-Type.
Der Content-Type ist der Schalter
import express from "express";
const app = express();
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.post("/echo", (req, res) => res.json({ body: req.body ?? null }));
// Ein Formular schickt von sich aus x-www-form-urlencoded. Damit
// deckst du den zweiten Fall mit einem Klick ab.
app.get("/", (req, res) =>
res.type("html").send(
'<form method="post" action="/echo">' +
'<p><input name="name" value="Mario"></p>' +
"<p><button>Abschicken</button></p>" +
"</form>"
)
);
app.listen(3000); Diesmal sind beide Parser angemeldet. Den Formularfall schickst du mit dem Button „Abschicken“ im
Reiter Browser ab, und ein Formular schickt von sich aus x-www-form-urlencoded. Die beiden anderen
Fälle gehen mit curl raus, einmal mit und einmal ohne JSON-Kopfzeile.
Ohne die Kopfzeile greift der falsche. curl -d schickt ohne eigene Angabe
application/x-www-form-urlencoded mit. Also hält sich express.urlencoded() für zuständig und
macht aus dem ganzen JSON einen einzigen Feldnamen mit leerem Wert. Die Antwort ist
{"body":{"{\"name\":\"Mario\"}":""}}. Ohne express.urlencoded() bliebe req.body undefined.
Jeder Parser schaut sich zuerst den Content-Type der Anfrage an und lässt den Rumpf liegen,
wenn er nicht zuständig ist. express.json() will application/json, express.urlencoded() will
application/x-www-form-urlencoded. Steht dort nichts oder etwas anderes, tut keiner der beiden
etwas.
Das ist auch richtig so. Sonst weiß ein Server nicht, wie er die Bytes deuten soll, und wer JSON
schickt, muss es deshalb dazusagen. Die andere Seite kennst du aus dem
JavaScript-Kurs, aus der Lektion „Daten schicken“. Dort stand ein fetch mit
JSON.stringify im Rumpf und Content-Type: application/json in der Kopfzeile. Fehlt die
Kopfzeile, schickt der Browser den Text als text/plain, und curl -d schickt ihn als Formular.
Ungefragt sagt keiner von beiden JSON.
Eine Obergrenze für den Rumpf
express.json({ limit: "100kb" }) begrenzt, wie viel angenommen wird. Der Standardwert liegt bei
100 Kilobyte, und wer ihn hochsetzt, braucht dafür einen Grund.
Ohne Grenze kann jemand ein Gigabyte schicken, und der Server sammelt es brav im Arbeitsspeicher, denn er kann ja nicht wissen, dass am anderen Ende niemand etwas Vernünftiges vorhat. Ein paar solche Anfragen gleichzeitig, und der Prozess ist tot. Dafür musste niemand eine Lücke ausnutzen. In der Synthese von Abschnitt 15 steht die Grenze deshalb auf einem Kilobyte.
POST /echo nimmt in der Aufgabe einen Namen als JSON entgegen und muss auch mit Anfragen
zurechtkommen, die keinen brauchbaren Rumpf mitbringen.
Zum Mitnehmen
Den Rumpf sammelt erst ein Parser wie express.json() ein, ohne ihn bleibt req.body undefined. Er greift nur bei passendem Content-Type und nimmt von sich aus höchstens 100 Kilobyte an.
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.