Contenido

Trabajando con Buffers en Node.js

¿Qué es un buffer?

Un buffer es básicamente un área reservada de menor de tamaño fijo. Es importante comprender que este tamaño no puede ser modificado con posterioridad. Los buffers estan ideados para trabajar con datos binarios. Es decir, no facilitan el manejo de información en binario frente a otros tipos en los que trabajamos con más frecuencia como es el caso de números o strings. En Node.js, los buffers son implementados con la clase Buffer.

¿Cual es la utilidad de un buffer?

La utilidad del buffer es muy especifica. Guardar datos binarios para poder ser consumidos con posterioridad. El típico ejemplo, el cual encontraras en otros miles de artículos, es cuando visualizas un video de YouTube y se descargan datos más rápido de lo que puedes ver el video. Esos datos se almacenan en un buffer para ser consumidos con posterioridad.

Lo que debe quedarte claro es que un buffer no es más que otro tipo y que la información que contiene esta representada en sistema binario.

Funcionalidades básicas con buffers

Crear un buffer

La clase Buffer de Node.js ofrece múltiples métodos para su creación:

  • Buffer.from() => const myBuffer = Buffer.from('holita!'); Este método genera un Buffer desde un objeto prexistente, que puede ser cualquiera de los que se indica en la parte superior. Buffer.from(array) Buffer.from(arrayBuffer[, byteOffset[, length]]) Buffer.from(buffer) Buffer.from(string[, encoding])

  • Buffer.alloc() => Buffer.alloc(128); y Buffer.allocUnsafe() => Buffer.allocUnsafe(128); Ambos métodos sirven para crear buffers con un determinado tamaño proporcionados. Sin embargo, hay que tener en consideración algo especial. Por la naturaleza asincrona de Node.js, la version insegura no garantiza que el buffer se cree completamente como esperamos y esto puede provocar errores. Por ello, se recomienda el uso del método alloc, garantizando que todo es como esperamos a costa de penalizar el rendimiento. Se recomienda siempre la creación de un buffer seguro y si aparecen problemas de rendimiento entonces buscar alternativas más optimas.

Acceder a su contenido

Hay dos formas de acceder al contenido de un buffer.

  • Método toString()
const myBuffer = Buffer.from('holita!');
console.log(myBuffer) // <Buffer 68 6f 6c 69 74 61 21>
console.log(buf.myBuffer()) // holita!
  • Sintaxis de array:
const myBuffer = Buffer.from('holita!')
console.log(myBuffer[0]) // 104
console.log(myBuffer[1]) // 111
console.log(myBuffer[2]) // 108
console.log(myBuffer[3]) // 105
console.log(myBuffer[4]) // 116
console.log(myBuffer[5]) // 97
console.log(myBuffer[6]) // 33
console.log(myBuffer[7]) // undefined

Los números son la correspondencia de cada letra en formato unicode. En el último caso, al tratarse de una longitud mayor, el log muestra undefined

Adicionalmente, hay que tener en cuenta que si creas un buffer con un tamaño determinado pero sin contenido en su interior, lo que ocurrirá es lo siguiente:

const myBuffer = Buffer.alloc(8) console.log(myBuffer) // <Buffer 00 00 00 00 00 00 00 00> console.log(myBuffer.toString()) //

Es decir, el buffer existe pero el último log no mostrará ninguna información porque realmente no hay nada en su interior.

Longitud de un buffer

const myBuffer = Buffer.from('Holita!') console.log(myBuffer.length) // 7

Modificar un buffer

Del mismo modo que para leer el contenido del buffer tenemos dos caminos, en este caso también es así:

  • Método write()

const myBuffer = Buffer.from('Holita!') console.log(myBuffer.toString()) // holita! myBuffer.write('adios!!') console.log(myBuffer.toString()) // adios!!

¿Qué ocurre si el string que deseas escribir es de longitud menor a la cadena de construcción? const myBuffer = Buffer.from('Holita!') console.log(myBuffer.toString()) // holita! myBuffer.write('buf!') console.log(myBuffer.toString()) // buf!a!

¿Y si intentas escribir un string de una longitud mayor al tamaño del buffer? const myBuffer = Buffer.from('Holita!') console.log(myBuffer.toString()) // holita! myBuffer.write('esternocleidomastoideo') console.log(myBuffer.toString()) // esterno

Es decir, ocurre ningún error pero debes considerar la perdida de información.

  • Sintaxis de array Utilizando la sintaxis array es igual de simple, solo debes tener en cuenta que debes sobreescribir con el formato unicode.

const myBuffer = Buffer.from('Holita!') myBuffer[0] = 111; // 111 es igual a la letra "o" en unicode console.log(myBuffer.toString()) // oolita!

Clonar/copiar un buffer

Puedes copiar un buffer de una forma simple utilizando el metodo copy(). Solo debes tener en cuenta el tamaño al crear el nuevo buffer, ya que si no tienen el mismo tamaño puede existir perdida de información. const myBuffer = Buffer.from('holita!') let myBufferCopied = Buffer.alloc(4) myBuffer.copy(myBufferCopied) console.log(myBufferCopied.toString()) // holi

En realidad, hay muchos más métodos de instancia que puedes utilizar para trabajar con buffers. Estos son solo los más populares. Sin embargo, creo que es suficiente para comprender su uso y poder responder a las preguntas de JSNAD acerca de buffers.