Implémenter un découpage de texte ligne par ligne avec TransformStream : LineSplitTransform

LineSplitTransform est une implémentation de TransformStream qui convertit les données binaires (Uint8Array) reçues depuis un flux en texte, puis les découpe selon les retours à la ligne.

Elle traite des morceaux de données continus et émet chaque ligne séparément, ce qui convient bien au traitement progressif de fichiers de logs ou de gros fichiers texte.

Implémentation

Utiliser TextDecoder pour convertir les octets en chaînes, puis découper sur les retours à la ligne avec la regex /\r?\n/.

Les lignes incomplètes conservées dans le buffer sont complétées avec le chunk suivant, et le contenu restant est aussi émis à la fin du flux.

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);
        }
      },
    });
  }
}

Exemple d’utilisation

Cet exemple envoie l’entrée standard dans LineSplitTransform, découpe le flux ligne par ligne et affiche chaque ligne dans la console.

import { LineSplitTransform } from './LineSplitTransform';

// Faire passer l'entrée standard dans LineSplitTransform
process.stdin.pipeThrough(new LineSplitTransform())
  .on('data', (line: string) => {
    console.log(`Ligne reçue : ${line}`);
  });

Cas d’usage

• Analyse en temps réel de logs ou de fichiers texte
• Traitement incrémental ligne par ligne de données reçues sur le réseau
• Implémentation de protocoles texte séparés par retours à la ligne

Résumé

Avec TransformStream, il est simple de mettre en place un mécanisme de traitement ligne par ligne pour des données de flux.

Comme les gros fichiers peuvent être traités progressivement sans être chargés entièrement en mémoire, cette approche permet un traitement texte efficace en mémoire.