Um buffer é um local específico na memória bruta. Ele serve como um espaço de armazenamento temporário para excesso de dados binários que a unidade de processamento não pode aceitar naquele momento específico.
Node.js inclui uma classe Buffer. Ele pode lidar com dados binários ao gerenciar fluxos TCP (Transfer Control Protocol) e operações de leitura e gravação em um sistema de arquivos.
Aprenda a criar, ler e alterar o conteúdo de um buffer.
Criando um buffer
Para criar um Buffer no Node.js, você usará o alloc() ou de() métodos. O alloc() O método cria um novo buffer, especificando seu tamanho durante a criação como o primeiro e único parâmetro obrigatório. É útil quando você não tem nenhum dado para armazenar no momento da criação do buffer.
Especifique o parâmetro de tamanho do buffer em bytes ao criar um buffer com o alloc() método. Por exemplo:
const buf = Buffer.alloc(8);
console.log (buf);
// saída:
A classe Buffer adiciona automaticamente zeros como valores de espaço reservado para novos dados quando você os cria com o alloc() método.
A classe Buffer expressa cada valor 0 como 00, usando o formato hexadecimal. Neste exemplo, ele contém um total de oito valores.
Para inicializar o Buffer com diferentes valores de espaço reservado, passe um segundo preencher parâmetro:
const buf_filled = Buffer.alloc(8, 5);
console.log (buf_filled);
// saída:
Este objeto cita uma parte da memória que armazena 8 bytes do valor 05. Observe que, embora você tenha passado um número como preencher parâmetro, os buffers armazenam dados apenas em binário.
Depois de alocar memória para o Buffer, grave os dados chamando o escrever() método:
const buf = Buffer.alloc(8);buf.write("v", "utf-8");
console.log (buf)
// saída:
buf.write("va","utf-8");
console.log (buf)
// saída:
O escrever() método usa codificação de caracteres para converter o primeiro parâmetro, usando utf-8 e então grava a string no Buffer. Adicionar um segundo caractere à string preencherá o segundo byte.
Para extrair dados de tipos de dados existentes, como strings ou arrays, use o de() método. Este método cria buffers de strings e arrays.
Por exemplo:
// Corda
const stringBuf = Buffer.from('corda')
console.log (stringBuf)
// saída:
// Variedade
const arrayBuf = Buffer.from([97, 114, 114, 97, 121], 'hex')
console.log (arrayBuf);
// saída:
O de() O método recebe a entrada como seu primeiro parâmetro, calcula o número de bytes necessários para codificar os dados e, em seguida, envia o resultado para o Buffer. Ao fornecer outro formato de codificação como o segundo parâmetro, você pode substituir a codificação padrão (UTF-8).
Passando números para o de() método resultará em um erro.
Lendo um Buffer
Embora os Buffers sejam semelhantes aos arrays, eles não são redimensionáveis e podem lidar com dados binários do computador graças aos métodos integrados.
A classe Buffer nos permite ler bytes individuais de seus dados usando a sintaxe de colchetes do JavaScript.
Por exemplo:
const meuBuf = Buffer.from('Meu');
console.registro(MyBuf[1]);
// saída: 105console.registro(MyBuf[3]);
// saída: 101
console.registro(MyBuf[5]);
// saída: indefinido
O bloco de código acima emprega a sintaxe de colchetes para obter os valores do primeiro e terceiro bytes em sua representação decimal. A tentativa de obter um byte inválido resultará em um indefinido erro.
Para acessar todos os seus dados, a classe Buffer vem com métodos toJSON() e para sequenciar(), que obtêm o conteúdo em dois formatos diferentes.
O para sequenciar() O método gera uma string como o conteúdo do buffer:
const meuBuf = Buffer.from('Meu');
console.registro(meuBuf.para sequenciar());
//saída: 'Minha'const numeroBuf = Buffer.from([123]);
console.registro(númeroBuf.para sequenciar())
// saída: '{'
const VazioBuf = Buffer.alloc(5);
console.registro(VazioBuf.para sequenciar());
// output: '\\x00\\x00\\x00\\x00\\x00'
A primeira chamada inicializa o Buffer com o valor “Meu”, que a chamada para toString replica. O segundo exemplo usa uma matriz single-int para inicialização, que possui uma representação de string como o “{" personagem. No último caso, um Buffer com cinco valores nulos retorna a string “\x00\x00\x00\x00\x00”. A corda \x00 é a representação hexadecimal de nulo.
O para sequenciar() O método sempre gera o resultado em formato de string, não importa com que tipo de dados você inicializa o Buffer.
O .toJSON() O método retorna a representação decimal dos dados do Buffer, independentemente dos dados que você usou para inicializar o Buffer.
Por exemplo:
const meuBuf = Buffer.from('Meu');
console.registro(meuBuf.toJSON());
// saída: { tipo: 'Amortecedor', dados: [ 77, 105, 110, 101 ] }
A saída JSON tem um tipo imóvel com valor de Amortecedor para indicar sua origem. Sua propriedade data armazena uma matriz de decimais que representa a matriz de bytes original.
Modificando um Buffer
Semelhante ao acesso a bytes individuais de um Buffer, você também pode modificar bytes individuais do conteúdo de um Buffer usando a sintaxe de colchetes.
Ao usar a sintaxe de colchetes para alterar um conteúdo individual, você pode atribuir apenas a representação decimal do valor.
Por exemplo:
meuBuf[0] = 70
console.registro(meuBuf.para sequenciar())
// saída: 'Bem'
Como os buffers são dados binários, você não pode atribuir uma string a uma parte específica de um buffer. Se você tentar definir um byte individual para uma string, o Buffer o traduzirá em um caractere nulo.
Por exemplo:
meuBuf[0] = 'F';
console.registro(meuBuf.para sequenciar());
// output: '\\x00ine'Como alternativa, você pode alterar todo o conteúdo de um buffer usando o escrever() método.
Considere inserir um índice fora do comprimento do Buffer. Em vez de retornar um erro, o Buffer ignora o índice inválido e mantém intacto o conteúdo original do Buffer.
Por exemplo, tente definir o quinto elemento de meuBuf para r através de sua representação decimal de 114:
meuBuf[4] = 114;
console.registro(meuBuf.para sequenciar());
//saída: 'Minha'
Observe que o para sequenciar() método retorna o mesmo valor 'Meu'.
Como você não pode redimensionar um Buffer, tentar gravar mais dados do que um pode conter resultará no descarte dos dados extras. Por exemplo:
const buf1 = Buffer.alloc(5)
buf1.write('número');
console.registro(buf1.para sequenciar())
//saída: 'número'
Usando o para sequenciar() método para confirmar os dados do buffer, ele retorna 'numbe' em vez de 'número'. Qual é o argumento inserido dentro do escrever() método.
Os buffers gravam em série começando no índice zero. O escrever() O método adiciona serialmente bytes a um Buffer, substituindo quaisquer dados anteriores.
Por exemplo:
const buf2 = Buffer.alloc(6);buf2.write('membro');
console.registro(buf2.para sequenciar())
// saída: 'membro'
buf2.write('oi');
console.registro(buf2.para sequenciar());
// saída: 'himber'
O código acima cria um buffer de seis bytes e adiciona a string “membro" para isso usando o escrever() método.
Em seguida, ele atualiza o buffer com novo conteúdo que ocupa menos espaço de memória do que o conteúdo anterior.
Isso resulta na criação de uma nova string com os dois primeiros bytes substituídos e os bytes restantes inalterados.
Muitas APIs e estruturas de dados usam buffers
Agora você sabe como criar um buffer, gravar em um, ler seu conteúdo e modificá-lo com os métodos apropriados.
Existem vários outros métodos disponíveis para trabalhar com a classe Node.js Buffer.
Você deve conhecer esses métodos e entender Buffers para entender como diferentes conceitos como fluxos e sistemas de arquivos funcionam.
