Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Buffers

24/31
Recursos

Aportes 62

Preguntas 7

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Buffer


Un buffer es un espacio de memoria (en la memoria ram), en el que se almacenan datos de manera temporal.

Es la forma mas cruda en la que se pueden almacenar los datos. (Se guardan en bytes y no se especifica el tipo de dato)

En la consola, los datos se muestran en formato hexadecimal.


<h3>Creacion de un bufer básico</h3>

Para crear un buffer, con 4 espacios por ejemplo, podemos hacerlo con la siguiente sintaxis.

let buffer = Buffer.alloc(4);
console.log(buffer); 
// Output:
//<Buffer 00 00 00 00>
<h3>Otras formas de crear un buffer</h3>

Datos en un arreglo

let buffer2 = Buffer.from([1,2,3]);
console.log(buffer2);

Datos de tipo string

let buffer3 = Buffer.from('Hola');
console.log(buffer3);
console.log(buffer3.toString());

Guardar el abecedario en un buffer

let abc =  Buffer.alloc(26);
console.log(abc);

for (let i = 0; i< abc.length; i++){
  abc[i] = i + 97;
}

console.log(abc);
console.log(abc.toString())

Creo que es importante destacar que el buffer no almacena los datos en binario, ya que cada espacio tiene 2 dígitos (almacenamiento hexadecimal).

Es por ello que la palabra Hola equivale en hexadecimal a 48 6f 6c 61

Link de convertidor a Hex: https://www.browserling.com/tools/text-to-hex

Si se preguntan porque 97, es debido a la la tabla ascii

Los buffer son conjuntos de datos en crudo, datos binarios, que podemos tratar en NodeJS para realizar diversos tipos de acciones

let buffer = Buffer.alloc(4);
let buffer2 = Buffer.from([1,2,3]);
let buffer3 = Buffer.from('Hola');

console.log(buffer);
console.log(buffer2);
console.log(buffer3);
console.log(buffer3.toString());

let abc =  Buffer.alloc(26);
console.log(abc);

for (let i = 0; i< abc.length; i++){
  abc[i] = i + 97;
}

console.log(abc);
console.log(abc.toString())```

Conversión de bases en JS. Usando toString()

const decimal = 32;
const binario = decimal.toString(2) // 100000
const octal = decimal.toString(8) // 40
const hexa = decimal.toString(16) // 20 --> 0x20 

Dale en el cora para que llegue a mas gente

¿Qué es un Buffer?
Buffers son objetos usados para represnetar un secuencia de bytes con una longitud fija. Es una subclase de Uint8Arrays y esta en el scope global. Estan diseñadas para trabajar con datos binarios.

¿Por qué usar Buffers?
JavaScript puro aunque bueno con cadenas de texto unicode no maneja muy bien datos binarios. Esto esta bien el el navegador donde casi toda la data proviene de strings. Sin embargo los servidores con Node también tienen que lidiar con TCP strams o con leet y escribir en el sistema de archivos. Ambos necesitan usar streams de datos binarios.

Una maneja de manjear esto es usar strings que es lo que Node intento hacer primero. Este approach resulto bastante problematico porque tiene una tendencia a romperse de maneas extrañas y misteriosas.

Buffers


Un buffer es una memoria de almacenamiento temporal de información que permite transferir los datos entre unidades funcionales.

  • alloc(*numero*) → Es un método de Buffer que crear un nuevo objeto buffer especificándole su tamaño.
let buffer = Buffer.alloc(4)

console.log(buffer)

También podemos crearlo con el método from, además que también puedes guardar strings y el buffer guardará los datos binarios que correspondan.

let buffer = Buffer.from([1,2,3])
let bufferDos = Buffer.from('hola')

Si le colocamos a la variable bufferDos el método .toString() descifrará el código y nos dará como resultado hola

Por ejemplo, podemos guardas un diccionario así:

// --------- Abecedario ----------
let abc = Buffer.alloc(26)
console.log(abc)

for (let i = 0; i < 26; i++) {
    abc[i] = i + 97
}

console.log(abc)
console.log(abc.toString())

Cuanto trabajamos con variables/constantes en string, estas no son cargadas en la memoria también? No comprendo del todo la utilidad en la vida real de los buffers ):

Para un tema nuevo siempre es necesario una motivación, con un pequeño cuento sobraba.
Buffers y Streams
https://www.youtube.com/watch?v=GlybFFMXXmQ

Aquí les dejo una lectura complementaria sobre Buffers en NodeJS

let buffer = Buffer.alloc(8);

let buffer = Buffer.from([1, 2, 3]);

let buffer = Buffer.from('Hola');

console.log(buffer);

console.log(buffer.toString());

//-------------------------

let abc = Buffer.alloc(26)

console.log(abc);

for (let i = 0; i < 26; i++) {
    abc[i] = i + 97;
}

console.log(abc);
console.log(abc.toString());

Buffer nos permite trabajar con datos en su versión más básica (sin tener que definir si son string, números o cualquier otro) - su versión binaria.

`var buffer = Buffer.alloc(8);
// Nos imprimira 8 bytes de 0.
// <Buffer 00 00 00 00 00 00 00 00>

var buffer = Buffer.from([ 8, 6, 7, 5, 3, 0, 9]);
// Nos imprimira 8 bytes con sus valores correspondientes.
// <Buffer 08 06 07 05 03 00 09>

var buffer = Buffer.from("Platzi");
// Nos imprimira
// <Buffer 70 6c 61 74 7a 69>

`

Es un espacio en memoria donde se almacenan datos de manera temporal, normalmente para un único uso; su principal uso es evitar que el programa o recurso , ya se hardware o software se qude sin datos durante una tranferencia de datos irregulares o por velocidad del proceso.
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

.
…

Buffer
Desde el puto de vista objetivo, un buffer lo podemos tratar, en alto nivel, con una cadena de tipo String. Sin embargo, ocuparemos los buffers en escenarios donde tenemos que extrapolar ese concepto a un conjunto en bruto o blob de información.
Con ello, es lo que se establecen a, un nivel complejo, el concepto de Stream o flujo de datos bajo canales.
Un ejemplo típico de utilización de este concepto es la descargsa de información de Youtube, al video exactamente, los cuales son descargados a través de chunks.

Que son los buffers?

Son datos en binarios que van viniendo y se van moviendo de un dato para otro.

¿Por qué Buffers?

JavaScript puro, aunque es excelente con cadenas codificadas en Unicode, no maneja muy bien datos binarios directos. Esto está bien en el navegador, donde la mayoría de los datos están en forma de cadenas. Sin embargo, los servidores de Node.js también tienen que lidiar con flujos de TCP y leer y escribir en el sistema de archivos, lo cual hace que sea necesario lidiar con flujos de datos puramente binarios.

Una forma de manejar este problema es simplemente usar cadenas de todos modos , que es exactamente lo que hizo Node.js al principio. Sin embargo, trabajar con este enfoque es extremadamente problemático; Es lento, te hace trabajar con una API diseñada para cadenas y no para datos binarios, y tiene tendencia a romperse de formas extrañas y misteriosas.

No uses cadenas binarias. ¡Utilice búferes en su lugar!

¿Qué son los búferes?

La Bufferclase en Node.js está diseñada para manejar datos binarios sin procesar. Cada búfer corresponde a una parte de la memoria bruta asignada fuera de V8. Los búferes actúan como matrices de números enteros, pero no se pueden cambiar de tamaño y tienen un montón de métodos específicamente para datos binarios. Los enteros en un búfer representan cada uno un byte y, por lo tanto, están limitados a valores de 0 a 255 inclusive. Cuando utilice console.log()para imprimir la Bufferinstancia, obtendrá una cadena de valores en valores hexadecimales.

Dónde ves búferes:

En la naturaleza, los búferes generalmente se ven en el contexto de datos binarios provenientes de secuencias, como fs.createReadStream.

Utilidad en la vida real

Las variables tienen un límite de lo que pueden contener. Además de un tipo asociado, y muchas funciones en su prototipo. El buffer es abstracto de todo eso, y simplemente tiene el dato en crudo. Luego lo puedes transformar en lo que quieras.

Además, el buffer puede tener un dato parcial en lugar de completo. En la próxima clase veremos cómo usarlo junto a un Stream.

console.clear()

// Vamos a guardar un trocito de memoria (en este caso se denota como argumento de la función, ahí dentro)
// let buffer = Buffer.alloc(1)

// Con from, podemos pasar un arreglo y estos serán los datos del buffer
// let buffer = Buffer.from([1,2,3])

// Con from, también podemos pasar cadenas, y esta se guardará como su información binaria y será expresada en hexadecimal
let buffer = Buffer.from("Hola")

// console.log(buffer)

// Los Buffers nos permiten trabajar con datos en su version mas cruda, sin tipos ni nada mas. 

// --

let abc = Buffer.alloc(26)
console.log(abc);

for( let i = 0; i < 26 ; i++ ) {
    abc[i] = i + 97
}

console.log(abc.toString());
//let buffer = Buffer.alloc(4);
//let buffer = Buffer.from([65, 2, 3]);
let buffer = Buffer.from('Hola')

//console.log(buffer.toString());

// --

let abc = Buffer.alloc(26);
console.log(abc);

for (let i = 0; i < 26; i++) {
    abc[i] = i + 97;
}

console.log(abc.toString());

Por si no saben el por que del numero 97:
97 en código ASCII la vocal a
Por si quieren reforzar el tema dejo este link:

el metodo alloc puede recibir 3 argumentos

Buffer.alloc(size[, fill[, encoding]])

size <integer-number> define el tamaño del buffer.
fill <string> | <Buffer> | <Uint8Array> | <integer> el valor a almacenar.
encoding <string> codificacion, si el fill es una string si codificaion por defecto es utf8.

fuente https://nodejs.org/docs/latest-v16.x/api/buffer.html#static-method-bufferallocsize-fill-encoding


let buffer = Buffer.alloc(4)
console.log(buffer)

let buffer2 = Buffer.from([1,2,3,6])
console.log(buffer2)

let buffer3 = Buffer.from('hola mundo')
console.log(buffer3)
console.log(buffer3.toString())

//abecedario en hexadecimal
let abc = Buffer.alloc(26)
for (let i= 0; i < 26;i++){
    abc[i] = i + 97;
}
console.log(abc.toString())

My code!

//let buffer =  Buffer.alloc(1);
//let buffer =  Buffer.from([1,2,3,4,4]);
//let buffer =  Buffer.from('hola');

//console.log(buffer.toString());

let abc =  Buffer.alloc(26);
console.log(abc)

for (let index = 0; index < 26; index++) {
    abc[index] = index + 97;
}
console.log(abc.toString());```

Buffer y Hex

Los Buffers en consola se representan cómo números base 16 ó hexadecimales.
Para entender los números Hex tenemos que entender los simbolos que los componen:

Es importante tener en cuenta que las letras en Hex representan un número más y no tienen relación con el abecedario.

Para encontrar el valor de un número hex, por ejemplo E7, multiplicamos el valor del primer digito 16 veces y sumamos el segundo valor y el resultado de la operación es el valor del hex en números decimales.

  • E7 = 231

  • 61 = a

Con la función toString() node toma el valor del buffer y lo convierte al simbolo que represente en la tabla ascii.

pd: Para entender mejor el tema de binarios, hex, y buffers tomar el curso de fundamentos de ingenieria de software 😃

Buffer

Son datos cifrados en hexadecimal ubicados en RAM, es decir que son volátiles (temporales).
Usamos Buffer para crear uno en código, ejemplo:

let buffer1 = Buffer.alloc(4);            //<Buffer 00 00 00 00>
let buffer2 = Buffer.from([1, 2, 3]);     //<Buffer 01 02 03>
let buffer3 = Buffer.from('hola');        //<Buffer 68 6f 6c 61>

Ejemplo de las letras del abecedario:

let abc = Buffer.alloc(26);
console.log(abc)                //<Buffer 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00>

for(let i = 0; i < 26; i++){
    abc[i] = i + 97;            //Buffer.from([97}) = A
};

console.log(abc);               //<Buffer 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 71 72 73 74 75 76 77 78 79 7a>
console.log(abc.toString());    //abcdefghijklmnopqrstuvwxyz

Buffer

Buffer son datos en binarios o datos en crudo que van de un lado a otro. Ejemplo 48 6f 6c 61 que significa Hola. Trabajar con buffers permite trabajar con la versión mas cruda de podemos tener sin generar que tipo de datos es.

//Crear un buffer
let crearBuffer = Buffer.alloc(1);
console.log(crearBuffer);
//Crear un buffer segun el argumento enviado
let otroBuffer = Buffer.from([1, 2, 5]);
let textoBuffer = Buffer.from('Hola');

console.log(otroBuffer);
console.log(textoBuffer);

También podemos trabajar posición a posición de un buffer y lo logramos rellenando el buffer como un arreglo de datos.

//trabajar un buffer puesto por puesto
let abc = Buffer.alloc(26);
console.log(abc);

for(let i = 0; i < 26; i++) {
  abc[i] = i + 97;
}

console.log(abc);
console.log(abc.toString());

Para concluir, buffer es un espacio en memoria con el cual podemos crear directamente con los datos que deseamos o crear el espacio en memoria e ir rellenándolo, esto nos permite trabajar con los datos mas primitivos de node logrando un flexibilidad en el manejo de cada dato o cada byte del buffer.

Los buffers me han servido para guardar imágenes que me llegan al servidor desde un dispositivo IoT mas o menos de esta forma lo hago:

const data = req.body

const buff = Buffer.from(data).toString('binary');
fs.writeFileSync(target_dir + fotoCorrel.toString() + ".jpg", buff, 'binary');

/* Son datos en binario que estan en movimiento */


/* Esto nos permite definir cuantos espacios para bites queremos guardar */
/* let buffer = Buffer.alloc(4); */

/* Aqui guardamos informacion en esos espacios */
/* let buffer = Buffer.from([1, 2, 5]); */


/* Nos da la traduccion de hola a datos binarios */
/* let buffer = Buffer.from('Hola'); */


let buffer = Buffer.from('Hola');

console.log(buffer.toString());

/* los buffers sirven para trabajar con informacion a un nivel de codigo mas bajo */

let abc = Buffer.alloc(26);
console.log(abc);

for (let i = 0; i < 26; i++) {
    abc[i] = i + 97;
}

console.log(abc);
console.log(abc.toString());

/* Esto todo pasa en memoria trabajamos con informacion bite a bite */

/* Los buffer son muy utile cuando se combinan con strings */

Lo que se debe rescatar es que tenemos la opción de trabajar con archivos en su más mínima expresión(binarios) que son los buffers

Usen esta tabla ASCII para conocer los códigos de los números, letras y símbolos especiales https://elcodigoascii.com.ar/

creacion de abecedario utilizando buffer

Muy interesante la forma en la que el profesor explica es más didáctica.

El Abecedario en Mayuscula

let abc = Buffer.alloc(26);  
console.log(abc);

for(let i=0; i< 26; i++){
   
    abc[i] = i + 65; 
}
console.log(abc.toString());

Cuando imprimimos el buffer, lo que vemos es cada una de las posiciones de este, que son bytes, con sus valores en hexadecimal. Un **byte **es equivalente a 8 bits. En decimal, un **byte **te permite acomodar valores numéricos de 0 a 255 y en hexadecimal equivale a valores desde 00 a FF.

Me ayudo mucho el .toString, como me hubiera gustado saber esto antes para no tener que hacer todos los calculos pero bueno es parte del aprendizaje y en esa ocasion me fue bastante util.

Buffers

Son datos binarios que se pasan en distintos lugares.

El buffer más sencillos es el siguiente:

let buffer = Buffer.alloc(4)
console.log(buffer)
// Output:
// <Buffer 00 00 00 00>

Devuelve una serie de datos sin información.

Para llenar esos datos se puede hacer lo siguiente:

let buffer = Buffer.from([1, 2, 3])
console.log(buffer)
//Output
//<Buffer 01 02 03>

let buffer = Buffer.from('Hola')
console.log(buffer)
//Output 
//<Buffer 48 6f 6c 61>

Cada posición del array es un conjunto de datos binarios. En el caso en que estamos poniendo el texto Hola , lo que devuelve la consola es el conjunto de datos binarios que representan el texto. Con el método toString() se puede enviar los datos como los podemos reconocer.

//Abecedarío
let abc = Buffer.alloc(26)
console.log(abc)

for (let i = 0; i < 26; i++) {
  abc[i] = i + 97
}
console.log(abc.toString())

//Output
// [nodemon] starting `node buffer.js`
/*
→ <Buffer 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
				00 00 00 00 00 00 00>
	
→ abcdefghijklmnopqrstuvwxyz
*/

En conclusión, el buffer son datos que nos permiten llenar de información como necesitemos, esto puede servir, para editar tipos de datos como pdf, csv, txt y convertirlos a otros formatos.

Necesitaba esta clase! era una traba que tenía en un manejador de imágenes

Me surgió la duda de cuanto era el tamaño máximo de almacenamiento en un buffer y segun la documentación oficial es de:

Ahora entiendo como funciona el streaming, no descarga los datos a disco si no que los va mostrando son buffers de datos

Los buffers normalmente no vienen solos, usualmente vienen con los streams

Dentro del for lo que se guardan son datos en hexadecimal en formato de 16bits que al convertirlos a string son caracteres del ascii

**> Quien recibe el buffer debe saber que tipo de dato es
**

**Quein envía el Buffer debe saber que tipo de datos es **

Cuando trabajamos con buffer, permite trabajar con el dato en la versión mas cruda que se pueda tener, sin generar tipos diferentes

¿Qué nos permite trabajar con Buffers?

**Buffer.From()😗*Asigna un nuevo búfer utilizando una matriz de bytes en el rango 0-255

**<Buffer 00>: ** significa que está vació y ha guardado un espacio en memoria

Buffer.alloc(): El método se utiliza para crear un nuevo objeto de búfer del tamaño especificado

Ejemplo de buffer

Ejemplo de Buffer cuando se trabaja con FileSystem

¿Qué son los Buffers?:
Son datos en binario, datos crudos, que van viniendo y se mueven de un lado a otro.

¿Qué son los Buffers?

Que interesante clase

.toString

Genial, vamos a streams

Los Buffers no son más que datos en binario que se van moviendo de un lado para otro, según entiendo, pueden contener cualquier tipo de información para luego trabajarla

buffer

Si alguien no puede acceder al modulo de Buffer de manera global, puede usar el siguiente codigo:

const {Buffer} = require('buffer');

let buffer = Buffer.alloc(4);

console.log(buffer);

Hola, conocen algún paquete de npm recomendado para manejar comunicacion serial (tipo pyserial en python)? me vendría genial con el tema de esta clase porque soy más de firmware :3
Gracias!

Cuando habla de memoria se refiere a la memoria RAM

Buffers para trabajar en memoria

Un buffer es un espacio de memoria (en la memoria ram), en el que se almacenan datos de manera temporal.