Skip to content

44.buferrs_no_node.md

Latest commit

 

History

History
150 lines (99 loc) · 4.91 KB

44.buferrs_no_node.md

File metadata and controls

150 lines (99 loc) · 4.91 KB

Buferrs no Node.js

Índice

O que é um Buffer?

Um buffer é uma área de memória. A maioria dos desenvolvedores de JavaScript está muito menos familiarizada com esse conceito, em comparação com os programadores que usam uma linguagem de programação de sistema (como C, C++ ou Go), que interagem diretamente com a memória todos os dias.

Ele representa um pedaço de memória de tamanho fixo (não pode ser redimensionado) alocado fora do mecanismo JavaScript V8.

Você pode pensar em um buffer como um array de inteiros cada um representando um byte de dados.

Ele é implementado pela classe Buffer Node.js.

Por que precisamos de um buffer?

Os buffers foram introduzidos para ajudar os desenvolvedores a lidar com dados binários, em um ecossistema que tradicionalmente lidava apenas com strings em vez de binários.

Os buffers no Node.js não estão relacionados ao conceito de armazenamento em buffer de dados. Isso é o que acontece quando um processador de fluxo recebe dados mais rápido do que pode digerir.

Como criar um buffer

Um buffer é criado usando os métodos Buffer.from(), Buffer.alloc() e Buffer.allocUnsafe().

const buf = Buffer.from('Hey!');

Você também pode apenas inicializar o buffer passando o tamanho. Isso cria um buffer de 1KB:

const buf = Buffer.alloc(1024);

ou

const buf = Buffer.allocUnsafe(1024);

Enquanto alloc e allocUnsafe alocam um Buffer do tamanho especificado em bytes, o Buffer criado por alloc será inicializado com zeros. Isso significa que, embora allocUnsafe seja bastante rápido em comparação com alloc, o segmento de memória alocado pode conter dados antigos que podem ser potencialmente confidenciais.

Dados mais antigos, se presentes na memória, podem ser acessados ou vazados quando a memória Buffer é lida. Isso é o que realmente torna o allocUnsafe inseguro e cuidados extras devem ser tomados ao usá-lo.

Usando um Buffer

Acessando o conteúdo de um Buffer

Um buffer, sendo um array de bytes, pode ser acessado como um array:

const buf = Buffer.from('Hey!');
console.log(buf[0]); // 72
console.log(buf[1]); // 101
console.log(buf[2]); // 121

Esses números são os bytes UTF-8 que identificam os caracteres no buffer (H -> 72, e -> 101, y -> 121). Isso acontece porque Buffer.from() usa UTF-8 por padrão. Tenha em mente que alguns caracteres podem ocupar mais de um byte no buffer (é -> 195 169).

Você pode imprimir o conteúdo completo do buffer usando o método toString():

console.log(buf.toString());

buf.toString() também é usado no UTF-8 por padrão.

Observe que se você inicializar um buffer com um número que define seu tamanho, você terá acesso à memória pré-inicializada que conterá dados aleatórios, não um buffer vazio!

Obtenha o tamanho de um buffer

Use a propriedade length:

const buf = Buffer.from('Hey!');
console.log(buf.length);

Iterar sobre o conteúdo de um buffer

const buf = Buffer.from('Hey!');
for (const item of buf) {
  console.log(item); // 72 101 121 33
}

Mudando o conteúdo de um buffer

Você pode gravar em um buffer uma string inteira de dados usando o método write():

const buf = Buffer.alloc(4);
buf.write('Hey!');

Assim como você pode acessar um buffer usando uma sintaxe de array, você também pode definir o conteúdo do buffer da mesma forma:

const buf = Buffer.from('Hey!');
buf[1] = 111; // o in UTF-8
console.log(buf.toString()); // Hoy!

Fatiar um buffer

Se você deseja criar uma visualização parcial de um buffer, pode criar uma slice. Uma slice não é uma cópia: o buffer original ainda é a fonte original. Se isso mudar, sua slice muda.

Use o método subarray() para criá-lo. O primeiro parâmetro é a posição inicial e você pode especificar um segundo parâmetro opcional com a posição final:

const buf = Buffer.from('Hey!');
buf.subarray(0).toString(); // Hey!
const slice = buf.subarray(0, 2);
console.log(slice.toString()); // He
buf[1] = 111; // o
console.log(slice.toString()); // Ho

Copiar um buffer

Copiar um buffer é possível usando o método set():

const buf = Buffer.from('Hey!');
const bufcopy = Buffer.alloc(4); // alocado 4 bytes
bufcopy.set(buf);

Por padrão, você copia todo o buffer. Se você deseja copiar apenas uma parte do buffer, você pode usar .subarray() e o argumento offset que especifica um deslocamento para gravar:

const buf = Buffer.from('Hey?');
const bufcopy = Buffer.from('Moo!');
bufcopy.set(buf.subarray(1, 3), 1);
console.log(bufcopy.toString()); // 'Mey!'