Módulo buffer
O JS foi originalmente projetado para navegadores, para que possa lidar bem com seqüências de cordas codificadas por unicode, mas não pode lidar bem com dados binários. Este é um problema com o Node.js, porque o Node.js foi projetado para enviar e receber dados que geralmente são transmitidos em formato binário na rede. por exemplo:
- Enviar e receber dados através da conexão TCP;
- Leia dados binários de imagens ou arquivos compactados;
- Leia e escreva dados do sistema de arquivos;
- Processar fluxos de dados binários da rede
O módulo buffer traz um método para o Node.js para armazenar dados brutos, para que dados binários possam ser usados no contexto de JS. Sempre que os dados foram movidos para operações de E/S precisam ser processados no Node.js, é possível usar o módulo de buffer.
Classe: Buffer
A classe buffer é um tipo de variável global usado para processar diretamente dados binários. Pode ser construído de várias maneiras.
Os dados brutos são salvos em uma instância da classe buffer. Uma instância buffer é semelhante a uma variedade de números inteiros
1.New Buffer (Tamanho): ALoque um novo buffer de tamanho de 8 bits, cujo tamanho é de tamanho.
2.New Buffer (Array): Atribua um novo buffer para usar uma matriz de bytes de 8 bits.
3.New Buffer (str, [codificação]): codificando o método de codificação do tipo string-o que é usado e os parâmetros são opcionais.
4. Método de classe: buffer.isEncoding (codificação): retorne true se a codificação de codificação fornecida for válida, caso contrário, retorne false.
5. Método da classe: Buffer.isBuffer (OBJ): Teste se este OBJ é um buffer. Retorna booleano
6. Método da classe: Buffer.Concat (List, [Totallength]): List {Array} Tipo de Array, Array de Buffer, costumava ser conectado. TotalLength {número} Tipo Tamanho total de todos os buffers da matriz de buffer acima.
Além de ler arquivos para obter instâncias de buffer, ele também pode ser construído diretamente, por exemplo:
A cópia do código é a seguinte:
var bin = novo buffer ([0x48, 0x65, 0x6c, 0x6c, 0x6c]);
O buffer é semelhante a uma string. Além de usar o atributo .Length para obter o comprimento do byte, você também pode usar o método [índice] para ler os bytes na posição especificada, por exemplo:
A cópia do código é a seguinte:
bin [0]; // => 0x48;
Buffer e String podem ser convertidos um ao outro, por exemplo, dados binários podem ser convertidos em strings usando uma codificação especificada:
A cópia do código é a seguinte:
var str = bin.toString ('utf-8'); // => "Olá"
Em vez de retornar um novo buffer, o método .slice retorna um ponteiro para um local no meio do buffer original, como mostrado abaixo.
A cópia do código é a seguinte:
1. [0x48, 0x65, 0x6c, 0x6c, 0x6c]
2. ^ ^
3. | |
4. Bin Bin.Slice (2)
Escreva para o buffer
A cópia do código é a seguinte:
var buffer = novo buffer (8); // Crie um buffer com 8 bytes de memória alocados
console.log (buffer.write ('a', 'utf8')); // saída 1
Isso escreverá o personagem "A" no buffer, e o nó retornará o número de bytes gravados no buffer após ser codificado. A codificação UTF-8 da letra A aqui ocupa 1 byte.
Copiar buffer
O Node.js fornece um método para copiar todo o conteúdo do objeto buffer em outro objeto buffer. Só podemos copiar entre objetos buffers existentes, então precisamos criá -los.
A cópia do código é a seguinte:
Buffer.copy (BufferTopyTo)
Entre eles, o BufferTocopyTo é o objeto de tampão de destino a ser copiado. O exemplo a seguir:
A cópia do código é a seguinte:
var buffer1 = novo buffer (8);
buffer1.write ('prazer em conhecê -lo', 'utf8');
var buffer2 = novo buffer (8);
buffer1.copy (buffer2);
console.log (buffer2.toString ()); // Prazer em conhecê -lo
Módulo de fluxo
Nos sistemas operacionais do tipo UNIX, o streaming é um conceito padrão. Existem três fluxos principais da seguinte forma:
1. Entrada padrão
2. Saída padrão
3. Erros padrão
Fluxo legível
Se o buffer for a maneira como o Node.js lida com dados brutos, o fluxo geralmente é a maneira como o Node.js move os dados. Os fluxos no Node.js são legíveis ou graváveis. Muitos módulos no Node.js usam fluxos, incluindo sistemas HTTP e arquivos.
Suponha que criemos um arquivo de colegas de classe e lemos a lista de nomes para que possamos usar esses dados. Como os dados são um fluxo, isso significa que, antes de concluir a leitura do arquivo, você pode atuar nos dados dos primeiros bytes recebidos. Este é um padrão comum em Node.js:
A cópia do código é a seguinte:
var fs = requer ('fs');
var stream = fs.readstream ('classmates.txt');
stream.setEncoding ('utf8');
stream.on ('dados', função (chunk) {
console.log ('Leia alguns dados')
});
Stream.on ('Close', function () {
console.log ('Todos os dados são lidos')
});
No exemplo acima, os dados do evento são acionados quando novos dados são recebidos. O evento de fechamento é acionado quando a leitura do arquivo é concluída.
Fluxo gravável
Obviamente, também podemos criar um fluxo gravável para escrever dados. Isso significa que apenas um script simples pode ser usado para ler no arquivo e depois gravar em outro arquivo:
A cópia do código é a seguinte:
var fs = requer ('fs');
var readableStream = fs.readstream ('classmates.txt');
var writableStream = fs.WriteStream ('names.txt');
readableStream.setEncoding ('utf8');
readableStream.on ('dados', função (chunk) {
writableStream.write (chunk);
});
readableStream.on ('Close', function () {
writableStream.end ();
});
Agora, quando um evento de dados é recebido, os dados são gravados no fluxo gravável.
readerable.setEncoding (codificação): retornar: isso
readable.resume (): o mesmo que acima. Este método permite que o fluxo legível continue acionando o evento de dados.
readable.Pause (): O mesmo que acima. Este método faz com que um fluxo no modo de fluxo pare de acionar o evento de dados, alternar para o modo não fluxo e deixar dados disponíveis subsequentes no buffer interno.
Classe: Stream.Writável
A interface de fluxo gravável é uma abstração dos dados que você está escrevendo em um destino.
1.Writable.Write (Chunk, [Encoding], [retorno de chamada]):
chunk {string | Buffer} dados a serem escritos
codificação {string} codificação, se o chunk for uma string
retorno de chamada {função} retorno de chamada após a redação do bloco de dados
Retorno: {boolean} true se os dados foram processados.
Este método grava dados no sistema subjacente e chama o retorno de chamada fornecido após o processamento dos dados.
2.Writable.Cork (): Forçado a prender todas as gravações.
Os dados presos serão gravados quando a chamada .uncork () ou .end () for chamada.
3.Writável.END ([Chunk], [codificação], [retorno de chamada])
chunk {string | Buffer} opcional, dados a serem gravados
codificação {string} codificação, se o chunk for uma string
retorno de chamada {função} opcional, retorno de chamada após o término do fluxo
Chamando Write () Após a chamada end () gerará um erro.
A cópia do código é a seguinte:
// Escreva 'Hello' e depois termine com 'mundo!'
http.createServer (function (req, res) {
res.Write ('Hello');
res. end ('mundo!');
// agora não tem permissão para continuar escrevendo
});