O Node.js é naturalmente assíncrono e orientado a eventos, e é ideal para lidar com tarefas relacionadas a E/S. Se você estiver lidando com operações relacionadas a E/S em seu aplicativo, poderá aproveitar os fluxos no Node.js. Portanto, vamos dar uma olhada nos fluxos em detalhes e entender como eles simplificam as operações de E/S.
O que é fluxo
Os fluxos são pipelines Unix que permitem ler facilmente os dados de uma fonte de dados e depois fluir para outro destino.
Simplificando, o streaming não é algo especial, é apenas uma empresa de eventos que implementa alguns métodos. De acordo com o método que implementa, o fluxo pode se tornar um fluxo legível (legível), um fluxo gravável (gravável) ou um fluxo bidirecional (duplex, legível e gravável).
Um fluxo legível permite ler dados de uma fonte de dados, enquanto um fluxo escritor permite gravar dados no seu destino.
Se você usou o Node.js, é provável que tenha encontrado streaming.
Por exemplo, em um servidor Node.js HTTP, a solicitação é um fluxo legível e a resposta é um fluxo gravável.
Você também pode ter usado o módulo FS, que pode ajudá -lo a lidar com fluxos legíveis e graváveis.
Agora, deixe você aprender alguns princípios básicos e entender diferentes tipos de fluxos. Este artigo discutirá fluxos legíveis e graváveis. Os fluxos bidirecionais estão além do escopo deste artigo e não os discutiremos.
Fluxos legíveis
Podemos usar um fluxo legível para ler dados de uma fonte de dados, que pode ser qualquer coisa, como um arquivo no sistema, um buffer na memória ou até outros fluxos. Como os fluxos são os EventEmitters, eles enviam dados com vários eventos. Usaremos esses eventos para fazer o fluxo funcionar.
Leia dados do fluxo
A melhor maneira de ler dados de um fluxo é ouvir eventos de dados e adicionar uma função de retorno de chamada. Quando os dados fluem, o fluxo legível enviará um evento de dados e a função de retorno de chamada será acionada. Dê uma olhada no seguinte snippet de código:
var fs = requer ('fs'); var readableStream = fs.creteReadStream ('file.txt'); var data = ''; var readableStream.on ('dados', function (chunk) {data += chunk;}); readableStream.on ('end', function () {console.Log (});};O FS.CreateReadstream fornecerá um fluxo legível.
No início, esse fluxo não era dinâmico de fluxo. Quando você adiciona o ouvinte de eventos da Data e adiciona uma função de retorno de chamada, ele se tornará fluido. Depois disso, ele lerá uma pequena parte dos dados e o passará para sua função de retorno de chamada.
O implementador do fluxo determina a frequência do gatilho do evento de dados. Por exemplo, a solicitação HTTP acionará o evento de dados quando vários KBs de dados forem lidos. Ao ler dados de um arquivo, você pode acionar o evento de dados quando uma linha é concluída.
Quando não há dados para ler (quando for lido no final do arquivo), o fluxo enviará um evento final. No exemplo acima, ouvimos este evento e imprimimos os dados quando terminamos de ler o arquivo.
Há outra maneira de ler fluxos. Você só precisa continuar chamando o método read () na instância do fluxo antes de ler até o final do arquivo.
var fs = requer ('fs'); var readableStream = fs.creteReadStream ('file.txt'); var data = ''; var chunk; readableStream.on ('readável', function () {while (chunk = readableStream.read ()! = null) {data += chunk;}); console.log (dados);});O método read () lê dados do buffer interno e retorna nulo quando não há dados para ler.
Portanto, no while loop, verificamos se o read () retorna nulo e, quando retornar nulo, o loop será encerrado.
Deve -se notar que, quando podemos ler dados do fluxo, o evento legível será disparado.
Set codificação
Por padrão, o que você lê do fluxo é um objeto buffer. Se você está lendo uma string, isso não é para você. Portanto, você pode definir a codificação do fluxo chamando readertable.setEncoding () como no exemplo a seguir:
var fs = requer ('fs'); var readableStream = fs.creteReadStream ('file.txt'); var data = ''; readableStream.setEncoding ('utf8'); readableStream.on ('dados', function (chunk) {data = = chunk;}); ledabLest.on ('end', '' ', funct), funct);No exemplo acima, se definirmos a codificação do fluxo como UTF8, os dados serão analisados no UTF8 e o pedaço na função de retorno de chamada será uma string.
Tubulação
Os pipelines são um ótimo mecanismo em que você pode ler dados de uma fonte de dados sem gerenciar o estado do fluxo e escrevê -los no seu destino. Vamos dar uma olhada no exemplo a seguir:
var fs = requer ('fs'); var readableStream = fs.createReadStream ('file1.txt'); var writableStream = fs.CreateWritSTream ('file2.txt'); readableStream.pipe (writableStream);O exemplo acima usa o método Pipe () para gravar o conteúdo do arquivo1 no arquivo2. Como o Pipe () o ajudará a gerenciar o fluxo de dados, você não precisa se preocupar com a velocidade do fluxo de dados. Isso torna o Pipe () muito simples e fácil de usar.
Deve -se notar que o Pipe () retorna o fluxo de destino, para que você possa vincular facilmente vários fluxos!
Link (encadeamento)
Suponha que haja um arquivo de arquivo e você deseja descompactá -lo. Existem muitas maneiras de realizar essa tarefa. Mas a maneira mais simples é usar pipelines e links:
var fs = requer ('fs'); var zlib = require ('zlib'); fs.cretereadstream ('input.txt.gz') .pipe (zlib.createGunzip ()) .Pipe (fs.createwritestream ('output.txt');Primeiro, criamos um fluxo legível via input.txt.gz e, em seguida, deixamos transmitir o fluxo zlib.createGunzip (), que descompacta o conteúdo. Por fim, adicionamos um fluxo gravável para escrever o conteúdo descompactado em outro arquivo.
Outros métodos
Discutimos alguns conceitos importantes em fluxos legíveis, e aqui estão algumas maneiras que você precisa saber:
1.Ilabable.Pause () Este método pausa o fluxo do fluxo. Em outras palavras, ele não acionará o evento de dados novamente.
2.Ilabable.Resume () O método é o oposto do acima e permitirá que o fluxo de pausa retome o fluxo.
3.Leabable.unpipe () Método removerá o destino. Se houver parâmetros passados, ele permitirá que o fluxo legível pare o destino específico de Liu Xiang, caso contrário, ele removerá todos os destinos.
Fluxos graváveis
Um fluxo gravável permite escrever dados em seu destino. Assim como fluxos legíveis, esses são os EventEmitters e também desencadeiam eventos diferentes. Vamos dar uma olhada nos eventos e métodos que serão acionados no fluxo gravável.
Escreva para transmitir
Para escrever dados como um fluxo gravável, você precisa chamar o método write () na instância de fluxo gravável e ver o seguinte exemplo:
var fs = requer ('fs'); var readableStream = fs.creteReadStream ('file1.txt'); var writableStream = fs.createwritestream ('file2.txt'); readableStream.setEncoding ('utf8'); readableSTream.on ('Data', função (chunk) {chunking (chunking);O código acima é muito simples, apenas lê os dados do fluxo de entrada e os grava no destino com Write ().
Este método retorna um valor booleano para indicar se a gravação é bem -sucedida. Se o retorno true, significa que a gravação é bem -sucedida e você pode continuar escrevendo mais dados. Se for falso, significa que algo ocorreu e você não pode continuar escrevendo agora. Um fluxo gravável desencadeia um evento de drenagem para dizer que você pode continuar escrevendo dados.
Depois de escrever os dados
Quando você não precisa escrever dados, você pode chamar o método End () para informar ao fluxo que terminou de escrever. Assumindo que res é um objeto de resposta HTTP, você geralmente enviará uma resposta ao navegador:
res.Write ('Alguns dados !!');
res.nd ();
Quando o end () é chamado, todos os dados são gravados e o fluxo acionará um evento de acabamento. Observe que, depois de ligar para end (), você não pode mais gravar dados no fluxo escrito. Por exemplo, o código a seguir relatará um erro:
res.Write ('Alguns dados !!');
res.nd ();
res.Write ('tentando escrever novamente'); // Erro!
Aqui estão alguns eventos importantes relacionados a fluxos graváveis:
1.Error dispara quando ocorre um erro ao escrever ou vincular
2.Pipe Quando o fluxo legível está vinculado ao fluxo gravável, este evento será acionado
3.Unpipe vai disparar quando o Unpipe for chamado por fluxo legível
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.