Tutorial de fluxos do Node js: Filestream, Pipes
James Hartmann
Fluxo de arquivos em Node.js
O Node faz uso extensivo de streams como mecanismo de transferência de dados.
Por exemplo, quando você envia algo para o console usando a função console.log, na verdade você está usando um fluxo para enviar os dados para o console.
O Node.js também tem a capacidade de transmitir dados de arquivos para que possam ser lidos e gravados adequadamente. Veremos agora um exemplo de como podemos usar fluxos para ler e escrever em arquivos. Precisamos seguir as etapas mencionadas abaixo para este exemplo
Passo 1) Crie um arquivo chamado data.txt que contém os dados abaixo. Suponhamos que este arquivo esteja armazenado na unidade D de nossa máquina local.
Tutorial sobre Node.js
Conheça
Eventos
Conectividade de Dados
Usando Jasmim
Passo 2) Escreva o código relevante que fará uso de fluxos para ler dados do arquivo.
var fs = require("fs");
var stream;
stream = fs.createReadStream("D://data.txt");
stream.on("data", function(data) {
var chunk = data.toString();
console.log(chunk);
});
Explicação do código: -
- Primeiro precisamos incluir os módulos 'fs' que contêm todas as funcionalidades necessárias para criar streams.
- A seguir, criamos um fluxo legível usando o método – createReadStream. Como entrada, fornecemos a localização do nosso arquivo data.txt.
- A função steam.on é um manipulador de eventos e nela especificamos o primeiro parâmetro como 'dados'. Isso significa que sempre que os dados vierem do arquivo no fluxo, execute uma função de retorno de chamada. No nosso caso, estamos definindo uma função de retorno de chamada que realizará 2 passos básicos. A primeira é converter os dados lidos do arquivo em uma string. A segunda seria enviar a string convertida como saída para o console.
- Estamos pegando cada pedaço de dados lido do fluxo de dados e convertendo-o em uma string.
- Finalmente, estamos enviando a saída de cada pedaço convertido de string para o console.
Saída:
- Se o código for executado corretamente, você verá a saída acima no console. Esta saída será a mesma do arquivo data.txt.
Escrevendo em um arquivo
Da mesma forma que criamos um fluxo de leitura, também podemos criar um fluxo de gravação para gravar dados em um arquivo. Vamos primeiro criar um arquivo vazio sem conteúdo chamado data.txt. Vamos supor que este arquivo seja colocado na unidade D do nosso computador.
O código abaixo mostra como podemos gravar dados no arquivo.
var fs = require("fs");
var stream;
stream = fs.createWriteStream("D://data.txt");
stream.write("Tutorial on Node.js")
stream.write("Introduction")
stream.write("Events")
stream.write("Generators")
stream.write("Data Connectivity")
stream.write("Using Jasmine")
Explicação do código: -
- Estamos criando um fluxo gravável usando o método – createWriteStream. Como entrada, fornecemos a localização do nosso arquivo data.txt.
- Em seguida, usamos o método stream.write para escrever as diferentes linhas de texto em nosso arquivo de texto. O stream se encarregará de gravar esses dados no arquivo data.txt.
Se você abrir o arquivo data.txt, verá agora os seguintes dados no arquivo
Tutorial sobre Node.js
Conheça
Eventos
Generators
Conectividade de Dados
utilização Jasmim
Tubos em Node.js
Dentro dos aplicativos Node, os fluxos podem ser canalizados usando o método pipe(), que leva dois argumentos:
- Um fluxo gravável obrigatório que atua como destino para os dados e
- Um objeto opcional usado para passar opções.
Um exemplo típico de uso de pipes, se você deseja transferir dados de um arquivo para outro.
Então, vamos ver um exemplo de como podemos transferir dados de um arquivo para outro usando pipes.
Passo 1) Crie um arquivo chamado datainput.txt que contém os dados abaixo. Suponhamos que este arquivo esteja armazenado na unidade D de nossa máquina local.
Tutorial sobre Node.js
Conheça
Eventos
Generators
Conectividade de Dados
Usando Jasmim
Passo 2) Crie um arquivo vazio em branco chamado dataOutput.txt e coloque-o na unidade D da sua máquina local.
Passo 3) Escreva o código abaixo para realizar a transferência de dados do arquivo datainput.txt para o arquivo dataOutput.txt.
var fs = require("fs");
var readStream = fs.createReadStream("D://datainput.txt");
var writeStream = fs.createWriteStream("D://dataOutput.txt");
readStream.pipe(writeStream);
Explicação do código: -
- Primeiro, estamos criando um “readstream” para nosso arquivo datainput.txt que contém todos os nossos dados que precisam ser transferidos para o novo arquivo.
- Precisamos então criar um “writestream” para nosso arquivo dataOutput.txt, que é nosso arquivo vazio e é o destino para a transferência de dados do arquivo datainput.txt.
- Em seguida, usamos o comando pipe para transferir os dados do fluxo de leitura para o fluxo de gravação. O comando pipe pegará todos os dados que chegam ao fluxo de leitura e os enviará ao fluxo de gravação.
Se você abrir agora o arquivo dataOutput.txt, verá todos os dados que estavam presentes no arquivo datainput.txt.
Eventos em Node.js
Os eventos são um dos conceitos-chave do Node.js e, às vezes, o Node.js é chamado de estrutura orientada a eventos.
Basicamente, um evento é algo que acontece. Por exemplo, se uma conexão for estabelecida com um banco de dados, o evento de conexão com o banco de dados será acionado. A programação orientada a eventos consiste em criar funções que serão acionadas quando eventos específicos forem acionados.
Vejamos um exemplo básico de definição de um evento em Node.js.
Vamos criar um evento chamado ‘data_received’. Quando este evento for acionado, o texto “dados recebidos” será enviado ao console.
var events = require('events');
var eventEmitter = new events.EventEmitter();
eventEmitter.on('data_received', function() {
console.log('data received succesfully.');
});
eventEmitter.emit('data_received');
Explicação do código: -
- Use a função require para incluir o módulo 'eventos'. Com este módulo, você poderá criar eventos em Node.js.
- Crie um novo emissor de eventos. Isso é usado para vincular o evento, que no nosso caso é “data_received” a uma função de retorno de chamada definida na etapa 3.
- Definimos uma função orientada a eventos que diz que se caso o evento “data_received” for acionado, devemos enviar o texto “data_received” para o console.
- Finalmente, temos um gatilho manual do nosso evento usando a função eventEmiter.emit. Isso acionará o evento data_received.
Quando o programa for executado, o texto “dados recebidos” será enviado ao console conforme mostrado abaixo.
Emissão de eventos
Ao definir eventos, existem diferentes métodos para eventos que podem ser invocados. Este tópico se concentra em examinar cada um deles detalhadamente.
- Manipuladores de eventos únicos
Às vezes você pode estar interessado em reagir a um evento apenas na primeira vez que ele ocorrer. Nessas situações, você pode usar o método once().
Vamos ver como podemos usar o método once para manipuladores de eventos.
Explicação do código: -
- Aqui estamos usando o método 'once' para dizer que para o evento 'data_received', a função de retorno de chamada deve ser executada apenas uma vez.
- Aqui estamos acionando manualmente o evento ‘data_received’.
- Quando o evento 'data_received' for acionado novamente, desta vez nada acontecerá. Isso se deve ao primeiro passo em que dissemos que o evento só poderia ser acionado uma vez.
Se o código for executado corretamente, a saída no log será 'dados_recebidos com sucesso'. Esta mensagem aparecerá apenas uma vez no console.
- Inspecionando ouvintes de eventos
Em qualquer ponto de sua vida, um emissor de evento pode ter zero ou mais ouvintes anexados a ele. Os ouvintes de cada tipo de evento podem ser inspecionados de diversas maneiras.
Se você estiver interessado em determinar apenas o número de ouvintes anexados, não procure além do método EventEmitter.listenerCount().
(Nota: Os ouvintes são importantes porque o programa principal deve saber se os ouvintes estão sendo adicionados rapidamente a um evento, caso contrário, o programa não funcionará corretamente porque os ouvintes adicionais serão chamados.)
Explicação do código: -
- Estamos definindo um tipo eventEmitter que é necessário para usar os métodos relacionados a eventos.
- Estamos então definindo um objeto chamado emissor que será usado para definir nossos manipuladores de eventos.
- Estamos criando 2 manipuladores de eventos que basicamente não fazem nada. Isso é simples em nosso exemplo apenas para mostrar como o método listenerCount funciona.
- Agora, quando você invocar o método listenerCount em nosso evento data_received, ele enviará o número de ouvintes de eventos anexados a este evento no log do console.
Se o código for executado corretamente, o valor 2 será mostrado no log do console.
- O evento newListener
Cada vez que um novo manipulador de eventos é registrado, o emissor do evento emite um evento newListener. Este evento é usado para detectar novos manipuladores de eventos. Normalmente você usa o evento newListener quando precisa alocar recursos ou executar alguma ação para cada novo manipulador de eventos.
var events = require('events');
var eventEmitter = events.EventEmitter;
var emitter = new eventEmitter();
emitter.on("newListener", function(eventName, listener) {
console.log("Added listener for " + eventName + " events");
});
emitter.on('data_received', function() {});
emitter.on('data_received', function() {});
Explicação do código: -
- Estamos criando um novo manipulador de eventos para o evento ‘newListener’. Assim, sempre que um novo manipulador de eventos for registrado, o texto “Adicionado ouvinte para” + o nome do evento será exibido no console.
- Aqui estamos escrevendo no console o texto “Adicionado ouvinte para” + o nome do evento para cada evento registrado.
- Estamos definindo 2 manipuladores de eventos para nosso evento 'data_received'.
Se o código acima for executado corretamente, o texto abaixo será mostrado no console. Isso apenas mostra que o manipulador de eventos 'newListener' foi acionado duas vezes.
Adicionado ouvinte para eventos data_received
Adicionado ouvinte para eventos data_received
Resumo
- Streams são usados em Node.js para ler e gravar dados de dispositivos de entrada-saída. Node.js faz uso da biblioteca 'fs' para criar fluxos legíveis e graváveis em arquivos. Esses fluxos podem ser usados para ler e gravar dados de arquivos.
- Pipes podem ser usados para conectar vários fluxos. Um dos exemplos mais comuns é canalizar o fluxo de leitura e gravação para a transferência de dados de um arquivo para outro.
- O Node.js geralmente também é marcado como uma estrutura orientada a eventos e é muito fácil definir eventos no Node.js. Podem ser definidas funções que respondem a esses eventos.
- Os eventos também expõem métodos para responder a eventos importantes. Por exemplo, vimos o manipulador de eventos once() que pode ser usado para garantir que uma função de retorno de chamada seja executada apenas uma vez quando um evento for acionado.