Tratamento de buffers em Node.js

JavaScript É uma linguagem que tem um bom manuseio de strings, mas como foi inicialmente projetada para lidar com documentos HTML, não é muito boa para lidar com dados binários, na verdade o JavaScript não tem um tipo de dados binários como tal, contém apenas números estruturados ou tipos.

Como já sabemos Node.js é baseado em JavaScript e pode lidar com protocolos de texto como HTTP, onde você também pode usar isso para estabelecer comunicação com bancos de dados, manipular imagens e até mesmo lidar com manipulação de arquivos e, devido ao que discutimos, fazer isso apenas com strings pode ser bastante complicado.

Mas para tornar essas tarefas de manipulação binárias muito mais fáceis, Node.js inclui uma implementação de buffer binário, que nos permite obter e definir os bytes de um buffer criado sem muitos problemas.

RequisitosPara realizar os exercícios propostos neste tutorial devemos ter uma instalação funcional de Node.js em nosso sistema, podemos dar uma olhada neste tutorial antes de continuar a nos aprofundar nele. Também é importante poder ter acesso a um editor de rich text para codificar os exemplos, podemos usar o que quisermos, no entanto, para sua facilidade de uso, recomendamos Texto Sublime o NotePad ++ que também tem plugins para a sintaxe JavaScript Y HTML.

Criação de buffer

Para criar um buffer, é tão simples quanto criar uma nova instância da classe Amortecedor(). Vamos ver como criamos um buffer simples com base em uma codificação UTF-8 da seguinte maneira:

 var buf = new Buffer ('Olá, mundo!'); console.log (buf);

Vamos executar nosso exemplo por console para ver a resposta que ele nos dá Node.js Em relação à criação do nosso buffer:

Como vemos, se imprimirmos nossa variável lustre, a resposta pode não ser o que esperávamos, mas devemos lembrar que estamos criando uma instância de Amortecedor e o que essa classe faz é codificar seu conteúdo de acordo com a codificação de caracteres específica.

Também podemos criar um buffer de string com outras codificações, que serão válidas desde que especifiquemos o mesmo que o segundo argumento, vejamos:

 var buf2 = novo Buffer ('9b38kte610la', 'base64'); console.log (buf2);

Como podemos ver, podemos especificar a codificação sem nenhum problema, vamos ver então quais tipos de codificação são aceitos e seus respectivos identificadores:

ascii - ASCIIEste é o tipo de codificação padrão e é limitado pela codificação de caracteres do mesmo nome.
utf8 - UTF-8Esta é uma variável com a codificação que pode representar cada caractere Unicode existente e esta é a codificação padrão do nosso buffer no caso de não especificarmos nenhum.
base64 - Base64Este é um tipo de codificação usado para representar dados binários em um tipo de formato de string. ASCII e é usado principalmente para incorporar dados binários em documentos de texto para garantir que os dados permaneçam intactos em seu transporte.
Além disso, se não temos o conteúdo inicial para nosso buffer e precisamos criar um, podemos fazê-lo especificando sua capacidade, para isso fazemos da seguinte forma:

 var buf = novo Buffer (1024);

Com isso, o que fazemos é criar um buffer de 1024 bytes para nossas operações futuras.

Tratamento de bytes no buffer

Depois de criar ou receber o buffer, podemos inspecioná-lo e alterar seu conteúdo. Primeiro, para acessar os bytes dentro dele, podemos usar os colchetes da seguinte maneira:

 var buf = new Buffer ('aqui está o conteúdo do meu buffer'); console.log (buf [10]);

Se executarmos nosso exemplo, obteremos a décima posição do buffer, podemos até mudar para a nona posição do buffer e ver o resultado, vamos ver como fica:

Como podemos ver, obtemos bytes aleatórios para as posições de nosso buffer, mesmo se precisarmos manipular o conteúdo de qualquer posição nele, podemos fazer algo como o seguinte:

 var buf = new Buffer ('aqui está o conteúdo do meu novo buffer'); buf [2] = 110; buf [6] = 180; buf [10] = 90; console.log (buf [2]); console.log (buf [6]); console.log (buf [10]);

Vamos ver a resposta do console do nosso exemplo:

Como vimos podemos modificar o conteúdo de certas posições dentro do nosso buffer sem muitos problemas, além disso podemos obter o tamanho do nosso buffer com a propriedade comprimento da seguinte forma:

 var buf = novo Buffer (100); console.log (buf.length);

Se formos observadores, podemos ver que a resposta de nosso console será 100, onde após obter este valor, podemos usá-lo para iterar em nosso buffer e, assim, manipular cada posição para obter seu valor ou definir um valor específico, vamos ver um exemplo simples disso:

 var buf = novo Buffer (100); para (var i = 0; i <buf.length; i ++) {buf [i] = i; } console.log (buf);

O que fizemos neste exemplo foi criar um novo amortecedor com uma capacidade de 100 bytes e então definimos cada byte com um valor começando de 0 a 99, finalmente vamos ver a resposta do console ao executar nosso exemplo:

Extração de dados de buffer

Outra característica interessante do buffer, uma vez que o tenhamos criado ou recebido, é ser capaz de extrair uma parte dele. Podemos "cortar" para dizer de alguma forma e criar outro buffer menor com aquela parte que cortamos, sem esquecer de especificar de e para onde vamos cortá-lo, vamos ver um exemplo para ilustrar o que explicamos:

 var buffer_complete = new Buffer ("este é o conteúdo do meu buffer que vamos cortar"); var buffer_small = full_buffer.slice (26, 55); console.log (buffer_small.toString ());

Como podemos ver, primeiro criamos a instância do nosso buffer com o conteúdo inicial e, em seguida, com a função fatiar () Especificamos de e para onde vamos obter o conteúdo, atribuímos o que obtemos a uma nova variável e finalmente decodificamos o conteúdo para poder visualizar o conteúdo do nosso segundo buffer, vamos ver a resposta do console ao executar o exemplo:

É importante mencionar que quando cortamos um novo buffer não estamos usando uma nova memória do sistema, este novo buffer usa a memória do pai, pois se refere apenas a ele, mas com um início e um fim diferentes. Isso pode causar alguns problemas se não tivermos cuidado, pois estamos trabalhando no mesmo buffer, para isso recomendamos trabalhar com o método cópia de para evitar os problemas, que veremos a seguir.

Copiando um buffer

Como mencionamos, ao cortar um buffer podemos ter alguns problemas se não formos cuidadosos, mas para isso temos o método cópia de, que nos permite copiar o conteúdo de um buffer em um novo buffer, usando uma nova instância e um novo espaço de memória, vejamos:

 var buffer1 = novo Buffer ("Número do buffer de conteúdo 1, conteúdo a ser copiado"); var buffer2 = novo Buffer (20); var startobj = 0; var startSource = 26; var sourceEnd = 50; buffer1.copy (buffer2, startobj, startSource, endSource); console.log (buffer2.toString ());

Como podemos ver, criamos dois buffers diferentes, onde o primeiro terá o conteúdo e o segundo terá apenas o tamanho, especificamos o início para o nosso segundo buffer, e da mesma forma indicamos o início e o fim para o novo buffer que iremos copiar, vamos ver a resposta do console ao executar o exemplo:

Decodificando um buffer

Como vimos nos exemplos anteriores, fomos capazes de imprimir o conteúdo original do nosso buffer usando o método para sequenciar (), isso que é chamado é decodificar o buffer, onde como a instância da classe Amortecedor() se não especificarmos nada, por padrão, decodificamos para UTF-8.

Podemos até fazer a transcodificação de uma string UTF-8 para base64 para mencionar um caso, vejamos:

 var stringutf8 = 'minha nova string'; var buf = novo Buffer (stringutf8); var base64string = buf.toString ('base64') console.log (base64string);

Finalmente, vamos ver como transcodificamos nossa string original:

Com isso, terminamos este tutorial onde aprendemos as maneiras de lidar com dados binários em Node.js obrigado a classe Amortecedor, o que nos permite manipulá-lo desde sua leitura, escrita, obtenção de pequenos pedaços, copiando-o para novas instâncias e até mesmo transformando esse buffer em novos tipos de codificação para sua manipulação em nossos programas.