mitmario.dev

Was ist ein Stream?

Node.js Sandbox 4 Min Lesezeit 4 BeispieleLektion 4 von 7

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.

Die ganze Datei auf einmal
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.

Eine Datei in Stücken lesen
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.

Jedes Stück einzeln umgewandelt
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“.

Denselben Job dem Stream überlassen
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, kostenlos

Zu 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.