Guia completo para streams em Node.js

Streams em Node.js são uma maneira poderosa de lidar com a leitura e gravação de dados de maneira contínua. Eles permitem processar dados de forma eficiente, especialmente ao lidar com grandes quantidades de informações ou operações de E/S. Este guia abordará os tipos de streams, como usá-los e exemplos práticos para ajudá-lo a entender como os streams funcionam no Node.js.

O que são fluxos?

Streams são objetos que permitem ler dados de uma origem ou gravar dados em um destino de maneira contínua. Eles são ideais para processar dados peça por peça, em vez de ler ou gravar arquivos inteiros ou buffers de uma só vez. Isso é especialmente útil ao trabalhar com grandes conjuntos de dados, pois pode reduzir significativamente o uso de memória.

Conceitos-chave

• Modo de fluxo: os dados fluem automaticamente da origem para o destino.
• Modo pausado: os dados precisam ser lidos manualmente na fonte.
• Streams legíveis: Streams dos quais você pode ler dados.
• Streams graváveis: Streams nos quais você pode gravar dados.
• Duplex Streams: Streams que podem ler e gravar dados.
• Transform Streams: Streams que modificam ou transformam os dados à medida que são lidos ou gravados.

Tipos de fluxos

1. Streams legíveis: esses streams permitem que você leia dados. Os exemplos incluem fs.createReadStream() e http.IncomingMessage.

2. Streams graváveis: esses streams permitem gravar dados. Os exemplos incluem fs.createWriteStream() e http.ServerResponse.

3. Duplex Streams: Esses streams podem ler e gravar dados. Os exemplos incluem soquetes TCP e net.Duplex.

4. Transform Streams: são um tipo de stream duplex que pode modificar os dados à medida que são lidos ou gravados. Os exemplos incluem zlib.createGzip() para compactação.

Criando fluxos legíveis

Você pode criar um fluxo legível usando o módulo fs integrado para ler arquivos ou usando stream.Readable para criar fluxos legíveis personalizados.

Exemplo: lendo um arquivo com um fluxo legível

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('example.txt', { encoding: 'utf8' });

// Handling the 'data' event
readableStream.on('data', (chunk) => {
    console.log('New chunk received:', chunk);
});

// Handling the 'end' event
readableStream.on('end', () => {
    console.log('No more data to read.');
});

Exemplo: fluxo legível personalizado

const { Readable } = require('stream');

class MyReadableStream extends Readable {
    constructor(options) {
        super(options);
        this.current = 0;
    }

    _read(size) {
        if (this.current  {
    console.log('Received:', chunk.toString());
});

Criando fluxos graváveis

Você pode criar fluxos graváveis ​​usando o módulo fs ou estendendo a classe stream.Writable.

Exemplo: Gravando em um arquivo com um fluxo gravável

const fs = require('fs');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Write data to the stream
writableStream.write('Hello, World!\n');
writableStream.write('Writing to a file using streams.\n');

// End the stream
writableStream.end(() => {
    console.log('Finished writing to file.');
});

Exemplo: fluxo gravável personalizado

const { Writable } = require('stream');

class MyWritableStream extends Writable {
    _write(chunk, encoding, callback) {
        console.log('Writing:', chunk.toString());
        callback(); // Call when done
    }
}

const myWritableStream = new MyWritableStream();
myWritableStream.write('Hello, World!\n');
myWritableStream.write('Writing to custom writable stream.\n');
myWritableStream.end();

Usando fluxos duplex

Fluxos duplex podem ler e gravar dados simultaneamente. Um caso de uso comum são os soquetes TCP.

Exemplo: Criando um Stream Duplex

const { Duplex } = require('stream');

class MyDuplexStream extends Duplex {
    _read(size) {
        this.push('Data from duplex stream\n');
        this.push(null); // No more data
    }

    _write(chunk, encoding, callback) {
        console.log('Received:', chunk.toString());
        callback();
    }
}

const myDuplexStream = new MyDuplexStream();
myDuplexStream.on('data', (chunk) => {
    console.log('Reading:', chunk.toString());
});

// Write to the duplex stream
myDuplexStream.write('Hello, Duplex!\n');
myDuplexStream.end();

Usando fluxos de transformação

Transform streams são úteis para modificar dados à medida que fluem pelo stream. Por exemplo, você pode usar um fluxo de transformação para compactar dados.

Exemplo: Criando um Fluxo de Transformação

const { Transform } = require('stream');

class MyTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        const upperChunk = chunk.toString().toUpperCase();
        this.push(upperChunk);
        callback();
    }
}

const myTransformStream = new MyTransformStream();
myTransformStream.on('data', (chunk) => {
    console.log('Transformed:', chunk.toString());
});

// Pipe data through the transform stream
process.stdin.pipe(myTransformStream).pipe(process.stdout);

Fluxos de tubulação

Um dos recursos poderosos dos streams é a capacidade de juntá-los. A tubulação permite conectar um fluxo legível a um fluxo gravável, o que facilita a transferência de dados.

Exemplo: Fluxos de tubulação

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('input.txt');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Pipe the readable stream to the writable stream
readableStream.pipe(writableStream);

writableStream.on('finish', () => {
    console.log('Data has been written to output.txt');
});

Transmitir eventos em Node.js

1. Eventos de fluxos legíveis

Fluxos legíveis emitem vários eventos importantes que ajudam você a gerenciar o fluxo de dados:

• data: Emitido quando um pedaço de dados está disponível para leitura.
• end: Emitido quando não há mais dados para ler.
• error: Emitido quando ocorre um erro durante a leitura.
• close: Emitido quando o fluxo e quaisquer recursos subjacentes (como descritores de arquivo) foram fechados.

Exemplo: eventos de fluxo legíveis

const fs = require('fs');

const readableStream = fs.createReadStream('example.txt');

readableStream.on('data', (chunk) => {
    console.log('Received chunk:', chunk.toString());
});

readableStream.on('end', () => {
    console.log('No more data to read.');
});

readableStream.on('error', (err) => {
    console.error('Error occurred:', err);
});

readableStream.on('close', () => {
    console.log('Stream closed.');
});

2. Eventos de fluxos graváveis

Streams graváveis ​​também emitem vários eventos:

• drain: Emitido quando o stream está pronto para aceitar mais dados após estar cheio.
• finish: Emitido quando todos os dados foram gravados no stream e o método end() foi chamado.
• error: Emitido quando ocorre um erro durante a escrita.
• close: Emitido quando o fluxo e quaisquer recursos subjacentes foram fechados.

Exemplo: eventos de fluxo graváveis

const fs = require('fs');

const writableStream = fs.createWriteStream('output.txt');

writableStream.on('finish', () => {
    console.log('All data has been written to output.txt');
});

writableStream.on('error', (err) => {
    console.error('Error occurred:', err);
});

// Writing data
writableStream.write('Hello, World!\n');
writableStream.write('Writing to a file using streams.\n');
writableStream.end(); // Call end to finish the writing process

3. Transformar eventos de streams

Transform streams herdam eventos de streams legíveis e graváveis ​​e emitem:

• data: Emitido quando um pedaço transformado está disponível para leitura.
• end: Emitido quando não há mais dados para transformar.
• error: Emitido quando ocorre um erro durante a transformação.
• finish: Emitido quando todos os dados foram processados ​​e gravados.

Exemplo: Transformar Eventos de Stream

const { Transform } = require('stream');

class MyTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        const upperChunk = chunk.toString().toUpperCase();
        this.push(upperChunk);
        callback();
    }
}

const myTransformStream = new MyTransformStream();

myTransformStream.on('data', (chunk) => {
    console.log('Transformed chunk:', chunk.toString());
});

myTransformStream.on('end', () => {
    console.log('No more data to transform.');
});

myTransformStream.on('error', (err) => {
    console.error('Error occurred:', err);
});

// Write data to the transform stream
myTransformStream.write('Hello, World!\n');
myTransformStream.write('Transforming this text.\n');
myTransformStream.end(); // End the stream

Resumo dos Eventos

• Streams legíveis: dados, fim, erro, fechamento
• Streams graváveis: drenar, terminar, erro, fechar
• Transform Streams: herda dados, fim, erro, término de fluxos legíveis e graváveis

Conclusão

Streams em Node.js fornecem uma maneira poderosa e eficiente de lidar com dados de maneira contínua. Eles permitem ler e gravar dados peça por peça, tornando-os particularmente úteis para operações de E/S e para trabalhar com grandes conjuntos de dados. Compreender como criar e usar diferentes tipos de fluxos, bem como lidar com eventos, ajudará você a construir aplicativos mais eficientes e escaláveis ​​em Node.js.

Esteja você criando fluxos legíveis, graváveis, duplex ou de transformação, a flexibilidade da API de fluxo permite que você lide com o processamento de dados da maneira que melhor atenda às necessidades do seu aplicativo.