在 Node.js 中使用流的好处-js教程-PHP中文网

在 Node.js 中使用流的好处

PHPz

发布： 2024-07-17 12:26:50

原创

570 人浏览过

Benefícios do Uso de Streams em Node.js

介绍

在处理大量数据时，在 Node.js 中使用流可以在性能和效率方面带来巨大的优势。流允许连续且分块地处理数据，从而避免将文件完全加载到内存中。本文探讨了使用流的好处，并通过实际示例演示了如何高效地转换大型文本文件。

什么是流？

流是 Node.js 中的一个抽象，它允许分块处理数据，而不是一次将所有内容加载到内存中。 Node.js 中有四种主要类型的流：

可读：我们可以读取数据的流。
可写：我们可以写入数据的流。
Duplex：可读可写的流。
转换：可以在数据通过时修改或转换数据的流。

流的好处

1. 内存效率

使用流，数据以块的形式处理，这意味着您不需要将整个文件加载到内存中。这对于大文件至关重要，因为它可以避免内存问题并提高系统性能。

2. 实时数据处理

流允许连续的数据处理。例如，您可以在仍在接收下一组数据的同时开始处理前一组数据，从而缩短总处理时间。

3. 保持响应能力

通过不阻塞 Node.js 事件循环，即使在 I/O 密集型操作期间，流也有助于保持应用程序的响应能力。

实际例子

生成测试文件

开始之前，让我们创建一个大文本文件进行测试。您可以使用以下Python脚本生成10GB文件：

# 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}")

登录后复制

要运行上述脚本，请将其保存为generator.py并使用以下命令运行它：

python3 generator.py

登录后复制

使用流转换文件

以下是 Node.js 中的代码，将 large-input.txt 的内容转换为大写并将结果保存在 large-output.txt 中。它还显示每 10% 的进度和总处理时间。

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

登录后复制