Zeilenweises Aufteilen von Text mit TransformStream: LineSplitTransform

LineSplitTransform ist eine TransformStream-Implementierung, die binäre Daten (Uint8Array) aus einem Stream in Text umwandelt und anhand von Zeilenumbrüchen trennt.

Sie verarbeitet fortlaufende Daten-Chunks und gibt jede Zeile einzeln aus. Dadurch eignet sie sich gut für die inkrementelle Verarbeitung von Logdateien und großen Textdateien.

Implementierung

Mit TextDecoder werden die Bytes in Zeichenketten umgewandelt und anschließend mit der Regex /\r?\n/ an Zeilenumbrüchen getrennt.

Unvollständige Zeilen bleiben im Buffer, werden durch den nächsten Chunk ergänzt und am Ende des Streams vollständig ausgegeben.

export class LineSplitTransform extends TransformStream<Uint8Array, string> {
  constructor() {
    let buffer = "";
    const decoder = new TextDecoder();
    const delimiterRegex = /\r?\n/;

    super({
      transform(chunk, ctrl) {
        buffer += decoder.decode(chunk, { stream: true });
        const lines = buffer.split(delimiterRegex);
        buffer = lines.pop() || "";

        for (const line of lines) {
          ctrl.enqueue(line);
        }
      },
      flush(ctrl) {
        buffer += decoder.decode();
        if (buffer.length > 0) {
          ctrl.enqueue(buffer);
        }
      },
    });
  }
}

Beispiel

Dieses Beispiel leitet Standard Input durch LineSplitTransform, teilt die Daten zeilenweise auf und gibt jede Zeile in der Konsole aus.

import { LineSplitTransform } from './LineSplitTransform';

// Standard Input durch LineSplitTransform leiten
process.stdin.pipeThrough(new LineSplitTransform())
  .on('data', (line: string) => {
    console.log(`Empfangene Zeile: ${line}`);
  });

Einsatzszenarien

• Echtzeitanalyse von Log- und Textdateien
• Inkrementelle zeilenweise Verarbeitung von Netzwerkdaten
• Implementierung zeilenbasierter Textprotokolle

Zusammenfassung

Mit TransformStream lässt sich eine zeilenweise Verarbeitung von Stream-Daten einfach umsetzen.

Da große Dateien schrittweise verarbeitet werden können, ohne vollständig in den Speicher geladen zu werden, ist dieser Ansatz speichereffizient.