Faedah Menggunakan Strim dalam Node.js

pengenalan

Apabila memproses volum data yang besar, penggunaan strim dalam Node.js boleh membawa kelebihan yang besar dari segi prestasi dan kecekapan. Strim membenarkan pemprosesan data secara berterusan dan dalam ketulan, mengelakkan pemuatan lengkap fail ke dalam memori. Artikel ini meneroka faedah menggunakan strim, menggunakan contoh praktikal untuk menunjukkan cara mengubah fail teks besar dengan cekap.

Apakah Strim?

Strim ialah abstraksi dalam Node.js yang membenarkan memproses data dalam ketulan dan bukannya memuatkan semuanya ke dalam memori sekaligus. Terdapat empat jenis strim utama dalam Node.js:

1. Boleh dibaca: aliran dari tempat kita boleh membaca data.
2. Boleh Ditulis: aliran tempat kita boleh menulis data.
3. Dupleks: strim yang boleh dibaca dan ditulis.
4. Ubah: strim yang boleh mengubah suai atau mengubah data semasa ia melaluinya.

Faedah Aliran

1. Kecekapan Memori

Menggunakan strim, data diproses dalam ketulan, yang bermaksud anda tidak perlu memuatkan keseluruhan fail ke dalam memori. Ini penting untuk fail besar, kerana ia mengelakkan masalah ingatan dan meningkatkan prestasi sistem.

2. Pemprosesan Data Masa Nyata

Strim membenarkan pemprosesan data berterusan. Sebagai contoh, anda boleh mula memproses bahagian pertama data semasa anda masih menerima yang seterusnya, yang menghasilkan jumlah masa pemprosesan yang lebih singkat.

3. Mengekalkan Responsif

Dengan tidak menyekat Gelung Peristiwa Node.js, strim membantu memastikan aplikasi responsif, walaupun semasa operasi intensif I/O.

Contoh Praktikal

Menjana Fail Ujian

Sebelum bermula, mari buat fail teks yang besar untuk ujian. Anda boleh menggunakan skrip Python berikut untuk menjana fail 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}")

Untuk menjalankan skrip di atas, simpan ia sebagai generator.py dan jalankannya menggunakan arahan:

python3 generator.py

Mengubah Fail Menggunakan Strim

Berikut ialah kod dalam Node.js yang mengubah kandungan large-input.txt kepada huruf besar dan menyimpan hasilnya dalam large-output.txt. Ia juga memaparkan kemajuan setiap 10% dan jumlah masa proses.

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

Faedah Pendekatan ini

1. Kecekapan Memori: Penggunaan strim membolehkan anda memproses volum data yang besar tanpa memuatkan keseluruhan fail ke dalam memori, mengelakkan limpahan memori dan meningkatkan prestasi.
2. Prestasi Terbaik: Memproses data dalam ketulan berterusan membolehkan anda mula memproses serta-merta, tanpa menunggu fail dimuatkan sepenuhnya.
3. Maklum Balas Masa Nyata: Paparan kemajuan masa nyata memberikan pandangan yang jelas tentang kemajuan pemprosesan, membolehkan pemantauan dan campur tangan pantas jika perlu.

Kesimpulan

Strim ialah alat yang berkuasa dalam Node.js untuk memanipulasi volum data yang besar. Menggunakan strim, anda boleh memproses fail dengan cekap, memastikan aplikasi responsif dan mengelakkan masalah memori. Contoh di atas menunjukkan cara mengubah fail teks besar menggunakan strim, memaparkan kemajuan dan jumlah masa proses.

Untuk mendapatkan butiran lanjut dan akses kepada kod penuh, lawati repositori GitHub saya.

Atas ialah kandungan terperinci Faedah Menggunakan Strim dalam Node.js. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!