Abschnitt 7 · Lektion 4
Was ist ein Stream?
readFile ist ein Eimer. Du hältst ihn hin, er wird gefüllt, und danach hast du alles. Das geht
gut, solange alles in den Speicher passt.
// Legt zugriffe.log an, eine Million Zeilen, jede siebte ein ERROR. Geschrieben
// wird in Bloecken, als ein einziger Text passte sie nicht in den Speicher.
import { appendFileSync, writeFileSync } from "node:fs";
let block = "";
writeFileSync("zugriffe.log", "");
for (let i = 1; i <= 1000000; i += 1) {
const stufe = i % 7 === 0 ? "ERROR" : i % 3 === 0 ? "WARN" : "INFO";
block += `2026-08-06T06:00:00Z ${stufe} Anfrage ${i} bearbeitet\n`;
if (block.length > 65536) {
appendFileSync("zugriffe.log", block);
block = "";
}
}
appendFileSync("zugriffe.log", block); import "./vorbereiten.js";
import { readFile, stat } from "node:fs/promises";
// stat kennt die Groesse der Datei in Bytes, ohne sie zu lesen.
const { size } = await stat("zugriffe.log");
console.log(`zugriffe.log: ${Math.round(size / 1000000)} MB`);
// Der Eimer: erst alles holen, dann zerlegen, dann zaehlen.
const zeilen = (await readFile("zugriffe.log", "utf8")).split("\n");
const stufen = { INFO: 0, WARN: 0, ERROR: 0 };
for (const zeile of zeilen) {
const stufe = zeile.split(" ")[1];
if (stufe in stufen) stufen[stufe] += 1;
}
console.log(stufen); vorbereiten.js schreibt ein Protokoll mit einer Million Zeilen, rund 52 MB. ganz.js zählt darin
die Stufen so, wie man es mit readFile aus Abschnitt 3 schreibt. Also alles lesen, an den
Zeilenumbrüchen zerlegen und durchzählen. Gestartet wird es mit
NODE_OPTIONS=--max-old-space-size=32, und das ist ein Deckel auf dem Speicher. Node bekommt für
seine Daten nur 32 MB, also weniger, als die Datei groß ist.
Im Terminal steht die Größe der Datei. Ein Ergebnis kommt nicht mehr. Stattdessen stehen dort ein
paar Zeilen über die letzten Versuche, Speicher frei zu räumen, dann
FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory und darunter
eine Liste von Adressen aus dem Inneren von Node. Der Speicher ist voll, und Node beendet den ganzen
Prozess. Ein try um das Lesen hilft nicht. Es gibt keinen Fehler, den es fangen könnte, nur einen
Prozess, der nicht mehr da ist.
Ohne den Deckel läuft dasselbe Programm durch. Mit node ganz.js aus der Befehlsleiste kannst du
das ausprobieren, und solange genug Speicher da ist, fällt das Problem lange nicht auf. Dabei
belegen seine Daten nach dem Zerlegen rund 100 MB, fast doppelt so viel, wie die Datei groß ist. Und
bei zehn gleichzeitigen Anfragen auf dieselbe Datei braucht jede ihren eigenen Eimer.
Ein Stream ist ein Gartenschlauch. Es kommt ein Stück (englisch chunk), du verarbeitest es und lässt es los, dann kommt das nächste. Im Speicher liegt immer nur ein Stück, egal wie groß die Datei ist.
Vier Arten, je ein Satz
Ein lesbarer Stream liefert Daten, aus einer Datei, einer Netzwerkantwort oder von der Tastatur.
Ein schreibbarer nimmt Daten entgegen, für eine Datei, eine HTTP-Antwort oder die Standardausgabe.
Ein Duplex kann beides gleichzeitig wie ein Netzwerk-Socket, und das eine hat dabei mit dem anderen nichts zu tun.
Ein Transform-Stream ist ein Duplex, bei dem das Ausgehende aus dem Eingehenden entsteht, etwa beim Komprimieren, beim Verschlüsseln oder wenn aus Kleinbuchstaben Großbuchstaben werden.
Einen Stream lesen
Die moderne und lesbare Form ist eine Schleife.
import { writeFileSync, createReadStream } from "node:fs";
writeFileSync("daten.txt", "x".repeat(5000));
let stuecke = 0;
let zeichen = 0;
for await (const stueck of createReadStream("daten.txt", { encoding: "utf8", highWaterMark: 1024 })) {
stuecke += 1;
zeichen += stueck.length;
}
console.log(`${stuecke} Stücke, ${zeichen} Zeichen`); for await ... of über einen lesbaren Stream gibt dir Stück für Stück. Wenn die Datei zu Ende ist,
ist auch die Schleife zu Ende. Wie groß ein Stück ist, steuert highWaterMark. Der Standardwert bei
Dateien sind 64 KiB. Im Beispiel steht 1024, damit man überhaupt mehr als ein Stück sieht.
Fünftausend Zeichen in Stücken zu je 1024 ergeben fünf Stücke, das letzte ist kürzer. Mehr Mechanik steckt nicht dahinter.
Was in einem Stück wirklich steckt
Ohne weitere Angabe liefert ein Datei-Stream keinen Text, sondern einen Buffer. Ein Buffer ist ein Stück Rohbytes, sonst nichts. Er weiß nicht, ob darin Text steht, und wenn ja, in welcher Kodierung.
Text wird daraus erst beim Umwandeln. Und da liegt die Falle. Ein Stück endet dort, wo die
eingestellte Größe erreicht ist, und nicht dort, wo ein Zeichen aufhört. In UTF-8 braucht ein ä
zwei Bytes, ein Emoji vier. Fällt die Grenze mittendurch, hat das eine Stück ein halbes Zeichen am
Ende und das nächste die andere Hälfte am Anfang.
import { writeFileSync, createReadStream } from "node:fs";
writeFileSync("umlaute.txt", "ä".repeat(3000));
let zeichen = 0;
let kaputte = 0;
for await (const stueck of createReadStream("umlaute.txt", { highWaterMark: 1023 })) {
const text = stueck.toString("utf8");
zeichen += text.length;
if (text.includes("�")) kaputte += 1;
}
console.log(`${zeichen} Zeichen statt 3000`);
console.log(`${kaputte} Stücke mit Buchstabensalat`); Dreitausend ä gehen hinein, und heraus kommen dreitausenddrei Zeichen. Sechs davon sind
Ersatzzeichen, die als Raute mit Fragezeichen erscheinen. Drei der fünf Grenzen gehen mitten durch
ein ä, und toString macht aus jeder Hälfte brav ein eigenes Ersatzzeichen.
Am Buffer liegt es nicht, sondern an der Stelle, an der umgewandelt wird. Es gibt kein „dieses Stück ist Text“, es gibt nur „dieser Stream ist Text“.
import { writeFileSync, createReadStream } from "node:fs";
writeFileSync("umlaute.txt", "ä".repeat(3000));
let zeichen = 0;
let kaputte = 0;
for await (const stueck of createReadStream("umlaute.txt", { encoding: "utf8", highWaterMark: 1023 })) {
zeichen += stueck.length;
if (stueck.includes("�")) kaputte += 1;
}
console.log(`${zeichen} Zeichen`);
console.log(`${kaputte} Stücke mit Buchstabensalat`); Ein encoding: "utf8" an createReadStream, und du bekommst Text statt Buffer. Der Stream hält
angebrochene Zeichen selbst zurück und hängt sie vorn an das nächste Stück. Dreitausend Zeichen,
kein Salat.
Die Grenze zwischen zwei Stücken
Ein encoding löst das Problem für Zeichen. Für alles, was länger ist als ein Zeichen, bleibt es
bestehen.
Ein Wort kann auf einer Stückgrenze zerfallen. Eine Zeile sowieso. Ein JSON-Objekt erst recht. Wenn du Stück für Stück nach einem Wort suchst, findest du die nicht, die genau auf der Naht liegen.
Der Ausweg ist jedes Mal derselbe. Ein Rest vom vorigen Stück geht vorn an das nächste, und wie lang dieser Rest sein darf, hängt davon ab, wonach du suchst.
In der Aufgabe zählt ein Stream, wie oft ERROR in einem Protokoll mit einer Million Zeilen steht.
Zum Mitnehmen
readFile holt die ganze Datei in den Speicher, ein Stream reicht sie in Stücken durch. Die Kodierung gehört an den Stream, und was länger ist als ein Zeichen, kann trotzdem auf zwei Stücke fallen.
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 4 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.