1. Análise de abertura
O chamado buffer de buffer significa "área de armazenamento temporário", que é uma peça de memória que armazena temporariamente dados de entrada e saída.
O idioma JS em si só possui tipos de dados de string e nenhum tipo de dados binário. Portanto, o NODEJS fornece um buffer de construtor global que é pare -par para fornecer operações sobre dados binários. 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 buffer = novo buffer ([0x68, 0x65, 0x6c, 0x6c, 0x6f]);
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:
buffer [0]; // 0x68;
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 = buffer.toString ("UTF-8"); // olá
Converte uma string em dados binários na codificação especificada:
A cópia do código é a seguinte:
var buffer = new Buffer ("Hello", "UTF-8"); // <buffer 68 65 6c 6c 6f>
Uma pequena diferença:
Há uma diferença importante entre um buffer e uma string. A string é somente leitura e qualquer modificação na string resulta em uma nova string, e a sequência original permanece inalterada.
Quanto ao buffer, é mais como uma matriz de idiomas C que pode fazer operações de ponteiro. Por exemplo, os bytes em uma determinada posição podem ser modificados diretamente no método [índice].
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
O método Slice não retorna um novo buffer, mas retorna um ponteiro para um local no meio do buffer original, como mostrado abaixo.
[0x68, 0x65, 0x6c, 0x6c, 0x6f]
^ ^
| |
bin bin.slice (2)
Portanto, a modificação do buffer retornada pelo método Slice atuará no buffer original, por exemplo:
A cópia do código é a seguinte:
var buffer = novo buffer ([0x68, 0x65, 0x6c, 0x6c, 0x6f]);
var sub = bin.slice (2);
sub [0] = 0x65;
console.log (buffer); // <buffer 68 65 65 6c 6f>
Se você deseja copiar um buffer, primeiro crie um novo buffer e copie os dados no buffer original através do método .copy.
Isso é semelhante a solicitar uma nova peça de memória e copiar os dados na memória existente. Aqui está um exemplo.
A cópia do código é a seguinte:
var buffer = novo buffer ([0x68, 0x65, 0x6c, 0x6c, 0x6f]);
var dup = novo buffer (bin.length);
buffer.copy (dup);
dup [0] = 0x48;
console.log (buffer); // <buffer 68 65 6c 6c 6f>
console.log (dup); // <buffer 48 65 65 6c 6f>
Em resumo, o Buffer estende os recursos de processamento de dados da JS, de strings a dados binários arbitrários.
O acima acima permite que você entenda o que é um buffer. Vamos falar sobre como usá -lo e os cenários de uso específicos abaixo.
Segundo, fale sobre buffer
O JavaScript é muito amigável para o processamento de cordas e, se é um byte amplo ou uma string de bytes única, é considerado uma string. O nó precisa processar protocolos de rede, bancos de dados operacionais, processamento de imagens, uploads de arquivos etc. e também precisam processar uma grande quantidade de dados binários. As cordas que vêm com elas estão longe de atender a esses requisitos, então o buffer surgiu.
Estrutura de buffer
O buffer é um módulo típico que combina JavaScript e C ++. A parte relacionada ao desempenho é implementada no C ++ e a peça não relacionada ao desempenho é implementada no JavaScript.
O nó é instalado na memória quando o processo é iniciado e o coloca no objeto global; portanto, não há necessidade de exigir.
Objeto de buffer: semelhante a uma matriz, seus elementos são dois dígitos em hexadecimal.
Alocação de memória de buffer
A alocação de memória do objeto de buffer não está na memória da v8, mas implementa o aplicativo de memória no nível C ++ do nó.
Para usar com eficiência o aplicativo de memória, o Node usa o mecanismo de alocação de laje, que é um mecanismo de gerenciamento de memória dinâmico que aplica vários sistemas operacionais *nix. Existem três estados de laje:
(1) completo: estado totalmente alocado
(2) Parcial: status de alocação parcial
(3) vazio: estado não atribuído
Conversão de buffer
Os objetos de buffer podem ser convertidos em strings, e os tipos de codificação suportados são os seguintes:
ASCII, UTF-8, UTF-16LE/UCS-2, base64, binário, hexadecimal
String para buffer
Novo buffer (STR, [codificação]), UTF-8 padrão
buf.Write (String, [offset], [comprimento], [codificação])
Buffer para string
buf.toString ([codificação], [start], [end])
Tipos de codificação que não são suportados por buffer
Determine se ele suporta -o por buffer.iscoding (codificação)
ICONV-LITE: Implementação pura de JavaScript, mais leve, melhor desempenho sem C ++ para JavaScript Conversão
Iconv: chamando a biblioteca Libiconv em C ++ completa
Splicing buffer
Nota "Res.on ('Data', function (chunk) {})", onde o pedaço de parâmetro é um objeto buffer. O uso diretamente de + costura será convertido automaticamente em uma string. Para caracteres de bytes largos, podem ocorrer um código ilegal.
Solução:
(1) Através do método setEncoding () no fluxo legível, esse método permite que o evento de dados passe um objeto de buffer, mas uma sequência codificada e o módulo StringEncoder é usado internamente.
(2) armazenar o objeto de buffer em uma matriz e finalmente montá -lo em um buffer grande e depois codificá -lo em uma saída de string.
O buffer é amplamente utilizado na E/S de arquivo e E/S de rede, e seu desempenho é de grande importância e é muito maior que o das seqüências de caracteres comuns.
Além da perda de desempenho da conversão de string, ao usar um buffer, uma configuração de marca de água alta é crucial para o impacto do desempenho ao ler um arquivo.
um. As configurações de marca alta têm um certo impacto na alocação e uso da memória buffer.
b. A configuração de marca de água alta é muito pequena, o que pode levar a muitas chamadas de sistema.
Quando devo usar o buffer, quando não devo usá-lo ------- JavaScript puro suporta o código Unicode, mas não suporta binário. Ao resolver fluxos de TCP ou fluxos de arquivo, é necessário processar fluxos. Quando salvamos strings não UTF-8, formatos binários e outros, devemos usar o "buffer".
3. Apresente exemplos
A cópia do código é a seguinte:
var BUF = new Buffer ("Este é o teste de concat de texto!"), str = "Este é o teste concat de texto!" ;
console.Time ("Teste concat de buffer!");
var lista = [];
var len = 100000 * buf.length;
for (var i = 0; i <100000; i ++) {
list.push (buf);
len += buf.length;
}
var s1 = buffer.concat (list, len) .toString ();
console.TimeEnd ("Buffer Concat Test!");
console.Time ("String Concat Test!");
var lista = [];
for (var i = 100000; i> = 0; i--) {
list.push (str);
}
var s2 = list.Join ("");
console.TimeEnd ("String Concat Test!");
A seguir, são apresentados os resultados em execução:
A velocidade de leitura é definitivamente mais rápida, e o buffer também requer a operação do ToString (). Então, quando salvamos strings, ainda precisamos usar string. Mesmo que consumimos cordas em cordas grandes, a velocidade das cordas não será mais lenta que os buffers.
Então, quando precisamos usar buffers novamente? Quando não há como salvarmos as seqüências de seqüências não UTF-8, formatos binários e outros, devemos usá-las.
Quatro, vamos resumir
(1) O JavaScript é adequado para o processamento de dados codificados do Unicode, mas não é amigável com o processamento de dados binários.
(2), portanto, ao processar fluxos de TCP ou sistemas de arquivos, é necessário processar fluxos de octeto.
(3), o Node possui vários métodos para processamento, criação e consumo de fluxos de octeto.
(4) Os dados brutos são armazenados em uma instância de buffer. Um buffer é semelhante a uma matriz inteira, mas sua memória é alocada fora da pilha V8. O tamanho de um buffer não pode ser alterado.
(5), os tipos de codificação processados são: ASCII, UTF8, UTF16LE, UCS2 (Alias para UTF16LE), Base64, Binário, Hex.
(6) O buffer é um elemento global e uma instância de buffer é obtida pelo buffer diretamente novo ().