Avantages de l'utilisation de Streams dans Node.js

Introduction

Lors du traitement de gros volumes de données, l'utilisation de flux dans Node.js peut apporter d'énormes avantages en termes de performances et d'efficacité. Les flux permettent le traitement des données en continu et par morceaux, évitant le chargement complet du fichier en mémoire. Cet article explore les avantages de l'utilisation des flux, à l'aide d'un exemple pratique pour démontrer comment transformer efficacement un fichier texte volumineux.

Que sont les flux ?

Les flux sont une abstraction dans Node.js qui permet de traiter les données en morceaux au lieu de tout charger en mémoire en même temps. Il existe quatre principaux types de flux dans Node.js :

1. Lisible : flux à partir desquels nous pouvons lire les données.
2. Writable : flux où l'on peut écrire des données.
3. Duplex : flux à la fois lisibles et inscriptibles.
4. Transformer : flux qui peuvent modifier ou transformer les données au fur et à mesure qu'elles les traversent.

Avantages des flux

1. Efficacité de la mémoire

À l'aide des flux, les données sont traitées par morceaux, ce qui signifie que vous n'avez pas besoin de charger un fichier entier en mémoire. Ceci est crucial pour les fichiers volumineux, car cela évite les problèmes de mémoire et améliore les performances du système.

2. Traitement des données en temps réel

Les flux permettent un traitement continu des données. Par exemple, vous pouvez commencer à traiter les premiers morceaux de données pendant que vous recevez encore les suivants, ce qui entraîne un temps de traitement total plus court.

3. Maintenir la réactivité

En ne bloquant pas la boucle d'événements Node.js, les flux aident à maintenir la réactivité de l'application, même pendant les opérations intensives en E/S.

Exemple pratique

Générer un fichier de test

Avant de commencer, créons un gros fichier texte à des fins de test. Vous pouvez utiliser le script Python suivant pour générer un fichier de 10 Go :

# generator.py

# Define o tamanho do arquivo em bytes (10GB)
file_size = 10000 * 1024 * 1024  # 10 GB

# Linha que será escrita repetidas vezes no arquivo
line = "This is a line of text to be transformed. Adding more text to increase the size of each line.\n"

# Calcula o número de linhas necessárias para preencher o arquivo
num_lines = file_size // len(line)

# Cria e escreve o arquivo
file_path = "large-input.txt"
with open(file_path, "w") as file:
    for _ in range(num_lines):
        file.write(line)

print(f"File created successfully at {file_path}")

Pour exécuter le script ci-dessus, enregistrez-le sous Generator.py et exécutez-le à l'aide de la commande :

python3 generator.py

Transformation du fichier à l'aide de flux

Voici le code dans Node.js qui transforme le contenu de large-input.txt en majuscules et enregistre le résultat dans large-output.txt. Il affiche également la progression tous les 10 % et la durée totale du processus.

// src/index.js

const fs = require('fs');
const { Transform } = require('stream');
const { performance } = require('perf_hooks');

// Caminho para o arquivo de entrada e saída
const inputFile = 'large-input.txt';
const outputFile = 'large-output.txt';

// Cria um Readable Stream a partir do arquivo de entrada
const readableStream = fs.createReadStream(inputFile, { encoding: 'utf8' });

// Cria um Writable Stream para o arquivo de saída
const writableStream = fs.createWriteStream(outputFile);

// Variáveis para rastreamento de progresso
let totalSize = 0;
let processedSize = 0;
let lastLoggedProgress = 0;
const startTime = performance.now();
let processedLines = 0;

fs.stat(inputFile, (err, stats) => {
  if (err) {
    console.error('Erro ao obter informações do arquivo:', err);
    return;
  }
  totalSize = stats.size;

  // Pipe o Readable Stream para o Transform Stream e depois para o Writable Stream
  readableStream
    .pipe(
      new Transform({
        transform(chunk, encoding, callback) {
          processedSize += chunk.length;
          processedLines += chunk.toString().split('\n').length - 1;

          // Converte o chunk de dados para letras maiúsculas
          const upperCaseChunk = chunk.toString().toUpperCase();

          // Chama o callback com o chunk transformado
          callback(null, upperCaseChunk);

          // Log de progresso
          const progress = (processedSize / totalSize) * 100;

          if (progress >= lastLoggedProgress + 10) {
            console.log(
              `Progresso: ${Math.floor(progress)}%, Linhas processadas: ${processedLines}`
            );
            lastLoggedProgress = Math.floor(progress);
          }
        },
      })
    )
    .pipe(writableStream)
    .on('finish', () => {
      const endTime = performance.now();
      const timeTaken = ((endTime - startTime) / 1000).toFixed(2);
      console.log('Transformação completa e arquivo salvo.');
      console.log(`Total de linhas processadas: ${processedLines}`);
      console.log(`Tempo total: ${timeTaken} segundos`);
    })
    .on('error', (err) => {
      console.error('Erro durante a transformação:', err);
    });
});

Avantages de cette approche

1. Efficacité de la mémoire : L'utilisation de flux vous permet de traiter de gros volumes de données sans charger l'intégralité du fichier en mémoire, évitant ainsi les débordements de mémoire et améliorant les performances.
2. Meilleures performances : le traitement des données en morceaux continus vous permet de démarrer le traitement immédiatement, sans attendre que le fichier se charge complètement.
3. Commentaires en temps réel : l'affichage de la progression en temps réel offre une vue claire de la progression du traitement, permettant une surveillance et une intervention rapide si nécessaire.

Conclusion

Les flux sont un outil puissant dans Node.js pour manipuler de gros volumes de données. Grâce aux flux, vous pouvez traiter les fichiers efficacement, en gardant l'application réactive et en évitant les problèmes de mémoire. L'exemple ci-dessus montre comment transformer un gros fichier texte à l'aide de flux, en affichant la progression et la durée totale du processus.

Pour plus de détails et accéder au code complet, visitez mon référentiel GitHub.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!