Streams Duplex são uma categoria fundamental de streams em Node.js. No entanto, eles são frequentemente mal compreendidos, incluindo o fluxo Duplex.
Esse tipo de fluxo é híbrido, o que significa que espera um método de leitura e gravação enquanto é implementado.
Neste artigo, revisaremos os streams Duplex e como criá-los. Mas antes disso, vamos nos atualizar sobre o que são streams.
Para esta postagem, o conhecimento de JavaScript e Node.js pode ajudar, mas não é necessário.
O que é um stream?
Streams são dados coletados de uma fonte e trazidos para outro local em uma sequência. O streaming de um vídeo online é um exemplo: enquanto o conteúdo do vídeo é passado para você em uma sequência, o conteúdo completo ainda não está disponível.
Os streams são divididos em quatro categorias: Gravável, Legível, Duplex e Transformar.
Streams legíveis lêem dados de um arquivo ou fonte e os passam para o aplicativo principal. Um buffer armazena os dados no caso de haver um atraso na transmissão dos dados para o aplicativo.
Quando o gravável transmite, a funcionalidade é oposta. Os dados são lidos do aplicativo para o arquivo. Também há um buffer se a transferência de dados ficar mais lenta e ele então o armazena lá.
Os fluxos duplex, por outro lado, são uma mistura dos fluxos legível e gravável, em que ambos os fluxos são independentes um do outro. outro.
Transform streams também são como Duplex, mas os streams legível e gravável estão conectados.
A conexão permite que o aplicativo grave dados no aplicativo, mas aí os dados devem ser manipulado antes de passar para o fluxo legível.
Exemplos de fluxo Duplex
Assim como explicamos anteriormente, o fluxo Duplex é basicamente uma mistura dos fluxos Legível e Gravável.
Um exemplo de fluxo Duplex é um Socket , que fornece dois canais para enviar e receber dados.
Outros exemplos de streams Duplex são:
soquetes TCP zlib streams streams de criptografia
Criando um fluxo duplex personalizado para atrasar os dados do bloco
Para criar um fluxo Duplex em Node.js, comece a importar os métodos necessários do módulo de fluxo:
const {PassThrough}=require (‘stream’) const tunnel=new PassThrough ()
O fluxo PassThrough é um tipo básico de fluxo Duplex que atua como um túnel para canalizar nosso fluxo legível para o fluxo gravável.
Então, com este túnel , podemos verificar o processamento de dados para o fluxo gravável.
A seguir, vamos ler um arquivo usando o fluxo legível e gravá-lo em um fluxo gravável usando writeStream agora:
const {PassThrough}=require (“Stream”); const {createReadStream, createWriteStream}=require (“fs”); const readStream=createReadStream (“./README.md”);//lê os dados deste arquivo const writeStream=createWriteStream (“./copy.txt”);//grava dados neste arquivo
A seguir, podemos verificar o que está no buffer para ver se os dados estão passando no túnel:
const {PassThrough}=require (“stream”); const {createReadStream, createWriteStream}=require (“fs”); const readStream=createReadStream (“./README.md”); const writeStream=createWriteStream (“./copy.txt”); túnel const=novo PassThrough (); tunnel.on (“dados”, (pedaço)=> {console.log (“bytes:”, pedaço);//bytes:
Além do PassThrough, temos o Throttle para atrasar quanto tempo os dados passam de uma fonte para outra no pipeline. Podemos usar fluxos Duplex para definir um atraso de quando os dados são trazidos para nosso aplicativo:
const {PassThrough, Duplex}=require (“stream”); const {createReadStream, createWriteStream}=require (“fs”); const readStream=createReadStream (“./movie.mp4”); const writeStream=createWriteStream (“./copy.mp4”); class Throttle extends Duplex {/* * O construtor da classe receberá as injeções como parâmetros. */construtor (tempo) {super (); this.delay=time; } _read () {}//Grava os dados, envia e define o atraso/tempo limite _write (trecho, codificação, retorno de chamada) {this.push (trecho); setTimeout (callback, this.delay); }//Quando todos os dados são transmitidos, ele para. _final () {this.push (null); }} túnel const=new PassThrough (); acelerador constante=novo acelerador (500); deixe quantidade=0; tunnel.on (“dados”, (pedaço)=> {quantidade +=pedaço.length; console.log (“bytes:”, quantidade);}); readStream.pipe (acelerador).pipe (túnel).pipe (writeStream);
Com o código acima, criamos um fluxo Duplex que cria aceleração (atraso) para nossos dados canalizados. Isso define um atraso de 500 milissegundos, e o método dentro da classe Throttle empurra o pedaço.
O método _final () só empurra nulo quando a transferência de dados é concluída.
Também modificamos nosso fluxo PassThrough para somar o comprimento de cada trecho que lê.
É assim que a resposta é processada no terminal em incrementos de 500 milissegundos:
Conclusão
Ao trabalhar com streams Duplex em Node.js, vimos como podemos atrasar a passagem de dados de um stream para outro.
Streams Duplex são muito importantes em nosso mundo digital e são usados na maioria das vezes sem a gente saber, principalmente no Socket. Esses são recursos poderosos por causa de como eles implementam os fluxos legível e gravável juntos.
