DEV Community: jorgeabad

Retos JS. Calculando factoriales muy grandes con JS.

jorgeabad — Sun, 09 Jul 2023 18:53:35 +0000

Factoriales muy grandes

Artículo en Factoriales muy grandes
Códigos del desafío en Desafío y Ejemplo

Todos los desafíos JS en Desafíos de Programación en JavaScript

El factorial del número entero n , escrito n! , Se define como:

$.×3×2×1n!=n\times(n - 1)\times ( n - 2)\times. . .\times3\times2\times1$

Desafio.

Calcular e imprimir el factorial de un entero dado.
Por ejemplo, si $n = 30$ , calculamos 30 x 29 x 28 x. . . x 2 x 1 y obtenemos 26525285981219105636308480000000.

Se ha de Completar la función extraLongFactorials.

extraLongFactorials tiene los siguientes parámetros:

n: un número entero

Formato de entrada del programa en la terminal.

La entrada consta de un solo entero n

Restricciones

$1 <= n <= 100$

Formato de salida.

Imprime el factorial de n .

Entrada de muestra

Salida de muestra

15511210043330985984000000

Explicación

25! = 25x24x23x. . . x 3 x 2 x 1

Problemática de los números grandes en JavaScript. BigInt

En JavaScript, el tipo de dato Number se utiliza para representar valores numéricos, todos los números se almacenan en un formato de punto flotante de 64 bits (estándar IEEE 754). Con este estándar, los enteros grandes no se pueden representar exactamente y se redondearán. Debido a esto, JavaScript solo puede representar números enteros de manera segura en el rango:

Entre 9007199254740991 + $2^{53} -1)$ y -9007199254740991 - $2^{53} -1)$ .

Los valores enteros fuera del anterior rango pierden precisión.

JavaScript tiene constantes llamadas Number.MAX_SAFE_INTEGER y Number.MIN_SAFE_INTEGER, que representan los valores máximos y mínimos seguros que se pueden representar de manera precisa con el tipo Number. Estos valores son, respectivamente:

console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991
console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991

Si intentamos realizar operaciones con números más grandes que Number.MAX_SAFE_INTEGER, podemos obtener resultados incorrectos debido a la falta de precisión. Veamos un ejemplo:

console.log(9007199254740992); // 9007199254740992
console.log(9007199254740992 + 1); // 9007199254740992
console.log(9007199254740992 + 2); // 9007199254740994

Como puedes ver, el resultado de 9007199254740992 + 1 no es el esperado, ya que el valor obtenido es el mismo que el número original. Esto se debe a que Number no puede representar con precisión números tan grandes.

¿Qué es BigInt?

El tipo BigInt fue introducido en ECMAScript 2020 para permitir el manejo de enteros arbitrariamente grandes. A diferencia del tipo Number, que se basa en el estándar IEEE 754 de punto flotante de 64 bits, BigInt utiliza una representación interna que no tiene límites en cuanto al tamaño de los números.

En el ejemplo anterior para utilizar BigInt, simplemente agregamos la letra "n" al final del número:

const numeroGrande = 9007199254740992n;
console.log(numeroGrande + 1n); // 9007199254740993n
console.log(numeroGrande + 2n); // 9007199254740994n

Ahora, los cálculos se realizan con precisión utilizando BigInt, y obtenemos los resultados correctos.

Constructor de `BigInt`

Para crear un valor BigInt, se puede utilizar el constructor BigInt() o añadir la letra n al final de un número entero.

const bigIntValue1 = BigInt(1234567890);
const bigIntValue2 = 9876543210n;

console.log(bigIntValue1); // 1234567890n
console.log(bigIntValue2); // 9876543210n

Operaciones con `BigInt`

Las operaciones aritméticas básicas, como suma, resta, multiplicación y división, se pueden realizar con BigInt de manera similar a los números normales.

const a = 1234567890n;
const b = 9876543210n;

const sum = a + b;
const difference = a - b;
const product = a * b;
const quotient = a / b;

console.log(sum); // 11111111100n
console.log(difference); // -8641975320n
console.log(product); // 12193263111263526900n
console.log(quotient); // 0n

Es importante tener en cuenta que la división de BigInt siempre produce un resultado redondeado hacia cero, ya que solo maneja números enteros.

Errores típicos con `BigInt`

Al trabajar con BigInt, es posible cometer algunos errores comunes:

Mezclar BigInt con Number: Debido a que BigInt es un tipo distinto, no se pueden mezclar directamente con Number en operaciones aritméticas. Es necesario convertir explícitamente entre ellos utilizando métodos como BigInt() o Number().

const a = 1234567890n;
const b = 123;

const sum = a + BigInt(b);
console.log(sum); // 1234568013n

Olvidar añadir la letra n: Es importante recordar que los literales BigInt deben terminar con la letra n para distinguirlos de los números normales. Si se olvida añadir la letra n, se creará un valor Number en su lugar.

const bigIntValue = 1234567890; // Esto es un Number, no un BigInt
console.log(bigIntValue); // 1234567890

Cometer errores de precisión en operaciones mixtas: Al realizar operaciones entre BigInt y Number, puede haber pérdida de precisión si el resultado supera el rango seguro de Number. Es importante convertir adecuadamente los valores a BigInt cuando se realizan cálculos que involucran BigInt.

const a = 9007199254740991n; // Valor máximo seguro de BigInt
const b = Number.MAX_SAFE_INTEGER;

const sum = a + BigInt(b);
console.log(sum); // 18014398509481982n (Valor correcto)

const incorrectSum = a + b;//Uncaught TypeError: Cannot mix BigInt and other types, use explicit conversions

SOLUCIÓN.

El fragmento de código JavaScript que se muestra a continuación implementa una función para calcular factoriales utilizando la técnica de memoización:

const factorial = (function() {
  let cache = {};

  function memoizedFactorial(n) {
    // Verificar si el resultado ya está en la caché
    if (n in cache) {
      return cache[n];
    }

    // Calcular el factorial recursivamente
    const result = n === 0 ? BigInt(1) : BigInt(n) * memoizedFactorial(n - 1);

    // Almacenar el resultado en la caché
    cache[n] = result;

    return result;
  }

  return memoizedFactorial;
})();

function extraLongFactorials(n) {
    console.log(`${String(factorial(n))}`);
  }

¿Qué es la memoización?

La memoización es una técnica utilizada en programación para almacenar y reutilizar los resultados de cálculos costosos. En lugar de calcular el resultado cada vez que se necesita, la memoización permite almacenar el resultado en una caché y recuperarlo cuando se requiera nuevamente. Esto mejora la eficiencia al evitar cálculos repetidos.

La función factorial utiliza la técnica de memoización para calcular factoriales de manera eficiente. La variable cache es un objeto que se utiliza como una estructura de datos para almacenar los resultados previamente calculados. Se inicializa como un objeto vacío.

La función interna memoizedFactorial es la encargada de realizar el cálculo del factorial. Toma un parámetro n que representa el número para calcular su factorial. Dentro de esta función, se verifica si el resultado para el número n ya está presente en la caché. Si es así, se retorna directamente el valor almacenado en la caché.

En caso de que el resultado no esté en la caché, se realiza el cálculo recursivo del factorial. Si n es igual a cero, se retorna BigInt(1) ya que el factorial de cero es uno. De lo contrario, se multiplica BigInt(n) por el factorial de n - 1 para obtener el resultado del factorial.

Una vez calculado el resultado, se almacena en la caché asociado al número n. Esto garantiza que los cálculos futuros para el mismo número se realicen de forma más eficiente al recuperar el resultado de la caché en lugar de realizar nuevamente los cálculos.

Finalmente, la función factorial se retorna como el resultado de la invocación de una función autoejecutable (function() { ... })(). Esto permite encapsular la variable cache y la función memoizedFactorial dentro de un contexto privado, evitando que sean accesibles desde el exterior.

La función extraLongFactorials es una función adicional que toma un parámetro n y muestra por consola el resultado del cálculo del factorial utilizando la función factorial implementada anteriormente. Convierte el resultado en una cadena de texto mediante String() para asegurarse de que se muestre correctamente en la consola.

En resumen, este código implementa una función para calcular factoriales utilizando la técnica de memoización y el tipo de dato BigInt para trabajar con números enteros grandes. La memoización permite almacenar y reutilizar los resultados previamente calculados, mejorando así la eficiencia del cálculo. El uso de BigInt permite manejar números enteros arbitrariamente grandes sin preocuparse por los límites numéricos estándar de JavaScript.

Ejemplo de uso.

const factorial = (function() {
  let cache = {};

  function memoizedFactorial(n) {
    if (n in cache) {
      console.log(`Recuperando el factorial de ${n} desde la caché`);
      return cache[n];
    }

    const result = n === 0 ? BigInt(1) : BigInt(n) * memoizedFactorial(n - 1);
    cache[n] = result;

    console.log(`Calculando el factorial de ${n}`);
    return result;
  }

  return memoizedFactorial;
})();

function extraLongFactorials(n) {
  console.log(`${String(factorial(n))}`);
}

// Ejemplo de uso
extraLongFactorials(20);
extraLongFactorials(20);
extraLongFactorials(25);

Al ejecutar este código, se calcula el factorial de 20 tres veces y el factorial de 25 una vez. Sin embargo, debido al uso de la técnica de memoización, se puede observar que el cálculo del factorial de 20 solo se realiza una vez. Las siguientes veces que se solicita el factorial de 20, se recupera directamente desde la caché, como se indica en los mensajes de consola:

Calculando el factorial de 20
2432902008176640000
Recuperando el factorial de 20 desde la caché
2432902008176640000
Calculando el factorial de 25
15511210043330985984000000

Esto demuestra la ventaja de utilizar la técnica de memoización. Los cálculos costosos solo se realizan una vez y los resultados se almacenan en la caché para su reutilización posterior. Como resultado, se mejora el rendimiento y se evitan cálculos innecesarios.

Uso del tipo de dato BigInt para números enteros grandes

En el código anterior, se utiliza el tipo de dato BigInt para manejar números enteros grandes en el cálculo de factoriales. Esto es necesario porque JavaScript tiene un límite en el tamaño de los enteros que puede representar de forma precisa.

Al utilizar BigInt, se pueden calcular factoriales para números enteros mucho más grandes sin perder precisión. En el ejemplo de uso, se calcula el factorial de 25 y se muestra correctamente en la consola:

Calculando el factorial de 25
15511210043330985984000000

Si se intentara realizar el cálculo sin utilizar BigInt, se obtendría un resultado incorrecto debido a los límites numéricos estándar de JavaScript.

En resumen, la combinación de memoización y el uso del tipo de dato BigInt en el cálculo de factoriales largos permite mejorar el rendimiento y calcular resultados precisos para números enteros grandes. La memoización evita cálculos repetidos almacenando resultados previamente calculados, mientras que BigInt proporciona la capacidad de trabajar con números enteros de gran magnitud.

CLASE BUFFER EN NODE.JS

jorgeabad — Wed, 05 Jul 2023 17:58:25 +0000

CLASE BUFFER EN NODE.JS

Actualmente, la clase “Buffer” de node.js implementa un API “Uint8Array” (“TypedArray” ES6) de una manera más optimizada y adecuada para los casos de uso Node.js. La clase “Buffer” es global por lo que es poco probable que uno tenga que utilizar alguna vez “require('buffer').Buffer”.

Node.js puede codificar y decodificar empleando las siguientes codificaciones: 'ascii', 'utf8', 'utf16le' (little endian), 'ucs2' que es un alias de 'utf16le', 'base64' codificación Base64, 'latin1', 'binary' que es un alias para 'latin1' y 'hex' codifica cada byte como dos caracteres hexadecimales. Si no se especifica la codificación emplea ‘utf8’.

A continuación se detallan alguno de los métodos y propiedades más importantes del módulo Buffer, para más detalle consultar la documentación.

Los códigos del post están disponibles en github

Creación, escritura y lectura de buffers.

Los códigos de todo apartado 15.4.1 están disponibles en github en el archivo buffer1.js

En versiones de Node.js anteriores a la v6, las instancias de Buffer se creaban utilizando la función constructora Buffer, por ejemplo “new Buffer(10)” asignaba un nuevo objeto “Buffer” de tamaño 10 bytes, el problema es que la memoria asignada para las instancias creadas de esta manera no eran inicializadas y podían contener datos confidenciales. Estas instancias de “Buffer” se debían inicializar manualmente utilizando el método “buffer.fill(0)” o escribiendo los datos completamente en el “Buffer”.

Con el fin de resolver el problema anterior el módulo Buffer ofrece cuatro formas asignar memoria “Buffer.from”, “Buffer.alloc”, “Buffer.allocUnsafe”, “Buffer.allocUnsafeSlow”.

Creación de buffer asignando tamaño.

Buffer.alloc(size[, fill[, encoding]]): Asigna un nuevo Buffer de tamaño “size” bytes, que se llena con el contenido pasado en “fill” que puede ser de tipo “String”, “Buffer” o “Integer”. Si el contenido “fill” es indefinido, el buffer se llenará a ceros. En el caso de que “fill” sea un String hay que indicarle la codificación de caracteres de la cadena, si no se indica por defecto usará “utf-8”

Buffer.allocUnsafe(size) y Buffer.allocUnsafeSlow(size): permiten crear una instancia de “Buffer” de tamaño “size” sin inicializar por lo que puede acceder a datos sensibles, es necesario inicializarlo mediante el método “fill”. El módulo “Buffer” pre asigna una instancia Buffer interna de tamaño “Buffer.poolSize” (por defecto 8192 bytes) que se utiliza como una agrupación para la asignación rápida de memoria a nuevas instancias de “Buffer” que van a ser creadas utilizando “Buffer.allocUnsafe() y allocUnsafeSlow()” solo cuando el tamaño “size” es menor o igual a la mitad de “Buffer.poolSize”, “Buffer.alloc” nunca usará la instancia que tiene pre asignada memoria.

console.log(Buffer.poolSize); //8192
console.log(Buffer.allocUnsafe(8)); //<Buffer b0 1f 62 30 0a 00 00 00>
console.log(Buffer.allocUnsafeSlow(8)); //<Buffer e8 d5 40 30 0a 00 00 00>
console.log(Buffer.allocUnsafe(8).fill(0)); //<Buffer 00 00 00 00 00 00 00 00>
console.log(Buffer.allocUnsafeSlow(8).fill(0)); //<Buffer 00 00 00 00 00 00 00 00>

Mediante la opción de línea de comandos “--zero-fill-buffers” se puede forzar a todos las instancias de “Buffer” creadas con Buffer.allocUnsafe(), Buffer.allocUnsafeSlow() a ser rellenadas automáticamente con ceros en su creación. El uso de esta opción cambia el comportamiento predeterminado de estos métodos y puede tener un impacto significativo en el rendimiento.

    node --zero-fill-buffers
    > Buffer.allocUnsafe(10);
    <Buffer 00 00 00 00 00 00 00 00 00 00>
    > Buffer.allocUnsafeSlow(10);
    <Buffer 00 00 00 00 00 00 00 00 00 00>

Modificar y obtener el valor de un byte por su posición.

buf[index] Mediante el operador [index] se puede obtener y establecer el valor de un byte que se encuentra en una determinada posición, “index”, de una instancia “buf” de “Buffer”. Los valores que se pueden asignar a cada byte estarán siempre entre 0x00 y 0xFF (hex) o 0 y 255 (decimal).

Leer y decodificar buffers

buf.toString([encoding[, start[, end]]]): Decodifica el contenido de una instancia, “buf”, de “Buffer” en una cadena de acuerdo con la codificación de caracteres especificado en “encoding”, “start” y “end” se emplean para decodificar sólo un subconjunto de “buf”.

buf.toJSON(): Devuelve la representación del objeto “buf” instancia de “Buffer” en un objeto “JSON”. JSON.stringify() es llamado implícitamente.

Para leer los valores que están almacenados en una instancia de “Buffer” como numéricos hay diferentes métodos en función de si lo queremos leer es un entero, coma flotante, si tiene signo o no, y si está representado con 8 bits, 16 bits o 32 bits en estos últimos casos si son BE o LE. Algunos de los métodos serían los siguientes: readDoubleBE, readDoubleLE, readFloatBE, readFloatLE, readInt8, readInt16BE, readInt16LE, readInt32BE, readInt32LE, readIntBE, readIntLE, buf.readUInt8, readUInt16BE, readUInt16LE, readUInt32BE, readUInt32LE, readUIntBE, readUIntLE. En todos los casos como parámetros se pasa un entero “offset” que representa el número de bytes que se deben omitir antes de comenzar a leer (en función del tipo de número como máximo podrá tener una determinado valor), y un booleano “noAssert” (Predeterminado: false) que permite saltar la validación de que el desplazamiento proporcionado sea correcto.

Veamos algunos ejemplos de lo expuesto hasta el momento, el código de los siguientes ejemplo y posteriores se encuentra en el archivo “Buffer.js”.

Creamos un buffer de tamaño 5 bytes inicializado todos sus bytes con el valor cero.

//Creamos un buffer 'buf0' de 5 bytes inicializado a ceros.
const buf0 = Buffer.alloc(5);
console.log("buf0:", buf0); //buf0: <Buffer 00 00 00 00 00>
//modificamos el primer byte de buf0 asignándole el valor 1
buf0[0] = 1;
console.log("buf0:", buf0); //buf0: <Buffer 01 00 00 00 00>

Creamos un buffer de 2 bytes y llenamos cada byte con el valor 255, leemos el primer byte y el segundo byte como un entero de 8 bits sin signo.

const bufi = Buffer.alloc(2, 255);
console.log("bufi", bufi); //bufi <Buffer ff ff>
console.log("bufi[0]", bufi, bufi.readUInt8(0)); //bufi[0] <Buffer ff ff> 255
console.log("bufi[1]", bufi, bufi.readUInt8(1)); //bufi[1] <Buffer ff ff> 255

Modificamos el primer byte asignándole el valor 1, leemos el valor del primer byte como un entero de 8 bits sin signo, y el valor de los 16 bits como un entero sin signo BE y LE.

bufi[0] = 1;
console.log("bufi[0]", bufi, bufi.readUInt8(0)); //bufi[0] <Buffer 01 ff> 1
console.log("bufi", bufi, bufi.readUInt16BE()); //bufi <Buffer 01 ff> 511
console.log("bufi", bufi, bufi.readUInt16LE()); //bufi <Buffer 01 ff> 65281

Modificamos el valor del primer byte asignándole el valor -2, leemos el primer byte como un entero de 8 bits con signo, y como un entero de 8 bits sin signo.

bufi[0] = -2;
console.log("bufi[0]", bufi, bufi.readInt8(0)); //bufi[1] <Buffer fe ff> -2
console.log("bufi[0]", bufi, bufi.readUInt8(0)); //bufi[1] <Buffer fe ff> 254

Creamos un nuevo Buffer de 10 bytes y lo rellenamos con los valores de “buf0”.

const buf1 = Buffer.alloc(12, buf0);
console.log("buf1:", buf1); //buf1: <Buffer 01 00 00 00 00 01 00 00 00 00 01 00>

Si queremos almacenar el carácter ‘ñ’ codificado en ‘utf-8’ tendremos que almacenarlo en un buffer que tenga por lo menos un tamaño de 2 bytes.

const buf2 = Buffer.alloc(2, "ñ");
console.log("buf2:", buf2, buf2.toString()); //buf2: <Buffer c3 b1> ñ

Si queremos almacenar el carácter ‘ñ’ codificado en ‘latin1’ lo podemos hacer mediante un buffer que solo tenga 1 byte.

const buf3 = Buffer.alloc(1, "ñ", "latin1");
console.log("buf3:", buf3, buf3.toString("latin1")); //buf3: <Buffer f1> ñ

También se puede pasar en la cadena los códigos Unicode con el carácter de escape “\”.

//Creamos un buffer de 2 bytes pasándole en la cadena el punto de código unicode
const bufUnicode = Buffer.alloc(2, "\u00F1", "utf8"); //ñ
console.log("bufUnicode:", bufUnicode, bufUnicode.toString()); //bufUnicode: <Buffer c3 b1> ñ
//Creamos un buffer de 3 bytes pasándole una cadena con la combinación de dos puntos de código unicode
const bufUniCompuesto = Buffer.alloc(3, "\u006E\u0303", "utf8");
console.log("bufUniCompuesto:", bufUniCompuesto, bufUniCompuesto.toString()); //bufUniCompuesto: <Buffer 6e cc 83> ñ

Creación de Buffer mediante el contenido a almacenar

Buffer.from(string[, encoding]): Crea un nuevo Buffer que contiene la cadena, “string”, pasada. Si se proporciona el parámetro de codificación, “encoding”, identifica la codificación de caracteres del parámetro “string” almacenando los bytes que se corresponden con la codificación especificada, si no se especifica la codificación por defecto emplea UTF-8.

const buf5 = Buffer.from("Buenos días UAH");
console.log("buf5: ", buf5, buf5.toString(), buf5.length, "bytes");
//buf5:  <Buffer 42 75 65 6e 6f 73 20 64 c3 ad 61 73 20 55 41 48> Buenos días UAH 16 bytes
const buf5Latin = Buffer.from("Buenos días UAH", "latin1");
console.log(
  "buf5Latin: ",
  buf5Latin,
  buf5Latin.toString("latin1"),
  buf5Latin.length,
  "bytes"
);
//buf5Latin:  <Buffer 42 75 65 6e 6f 73 20 64 ed 61 73 20 55 41 48> Buenos días UAH 15 bytes
console.log("ascii", buf5.toString("ascii")); //ascii Buenos dC-as UAH
console.log("latin-1", buf5.toString("latin1")); ////latin-1 Buenos dÃ¬as UAH
const buf6 = Buffer.from("4275656e6f732064c3ad617320554148", "hex");
console.log("buf6:", buf6, buf6.toString(), buf6.length, "bytes");
//buf6: <Buffer 42 75 65 6e 6f 73 20 64 c3 ad 61 73 20 55 41 48> Buenos días UAH 16 bytes
const buf_compuesto = Buffer.from("\u006E\u0303", "utf8"); //Unicode U+006E "n" + U+0303 “~”.
console.log(
  "buf_compuesto",
  buf_compuesto,
  buf_compuesto.toString(),
  buf_compuesto.length,
  "bytes"
);
//buf_compuesto <Buffer 6e cc 83> ñ 3 bytes

Buffer.from(buffer): Copia los datos pasados en el “buffer” (tipo “Buffer”) a una nueva instancia de Buffer.

const buf7 = Buffer.from(buf6);
buf7[0] = 0x62;
console.log("buf7:", buf7, buf7.toString());
//buf7: <Buffer 62 75 65 6e 6f 73 20 64 c3 ad 61 73 20 55 41 48> buenos días UAH

Buffer.from(array): Asigna un nuevo “Buffer” utilizando una “array” de octetos, que puede venir en codificación decimal o hexadecimal.

console.log("Buffer.from(array)");
console.log(Buffer.from([195, 177]).toString()); //ñ
console.log(Buffer.from([0xc3, 0xb1]).toString()); //ñ
console.log(Buffer.from([195, 0xb1]).toString()); //ñ
console.log(Buffer.from([0xf1]).toString("latin1")); //ñ
console.log(Buffer.from([0x6e, 0xcc, 0x83]).toString()); //ñ;

Buffer.from(arrayBuffer[, byteOffset[, length]]): copia los datos desde un objeto de tipo ArrayBuffer. Cuando pasa una referencia a la propiedad “.buffer” de una instancia TypedArray, el Buffer recién creado compartirá la misma memoria asignada que TypedArray.

const miBuffer = new ArrayBuffer(2);
const vista = new Uint8Array(miBuffer);
vista[0] = 195;
vista[1] = 177;
console.log(miBuffer); //ArrayBuffer { byteLength: 2 }
console.log(vista); //Uint8Array [ 195, 177 ]
const buf = Buffer.from(vista.buffer);
console.log(buf, buf.toString()); //<Buffer c3 b1> 'ñ'
vista[1] = 145;
console.log(buf, buf.toString()); //<Buffer c3 91> 'Ñ'

Llenado de un buffer.

buf.fill(value[, offset[, end]][, encoding]): Rellena una instancia “buf” de Buffer, desde una posición determinada “offset” hasta una posición final “end” con el “value” (String, integer, buffer) especificado. Si el “offset” y el “end” no son pasados, se llena el Buffer completo.

//U2600; bytes UTF8(hex e29880, dec [226 152 128]); char:☀
const buf4 = Buffer.alloc(3, "e29880", "hex");
console.log("buf4:", buf4, buf4.toString());
//buf4: <Buffer e2 98 80> ☀

//llenamos buf1 con la cadena 'hola' en utf8
buf1.fill("hola");
console.log("buf1:", buf1, buf1.toString());
//buf1: <Buffer 68 6f 6c 61 68 6f 6c 61 68 6f 6c 61> holaholahola

//llenamos a partir del 4º byte hasta el 9º byte incluido con cadena de 5 bytes.
buf1.fill(" UAH ", 4, 9);
console.log("buf1:", buf1, buf1.toString());
//buf1: <Buffer 68 6f 6c 61 20 55 41 48 20 6f 6c 61> hola UAH ola

//llenamos a partir del 9º byte hasta el 12º byte incluido con otro buffer de 3 bytes.
buf1.fill(buf4, 9, 12);
console.log("buf1:", buf1, buf1.toString());
//buf1: <Buffer 68 6f 6c 61 20 55 41 48 20 e2 98 80> hola UAH ☀

//llenamos a partir del 9º byte hasta el 12º byte incluido con '!' el código 33 en utf8
buf1.fill(33, 9, 12);
console.log("buf1:", buf1, buf1.toString());
//buf1: <Buffer 68 6f 6c 61 20 55 41 48 20 21 21 21> hola UAH !!!

//llenamos a partir del 9º byte hasta el 12º byte incluido con el caracter unicode u2661.
buf1.fill("\u2661", 9, 12);
console.log("buf1:", buf1, buf1.toString());
//buf1: <Buffer 68 6f 6c 61 20 55 41 48 20 e2 99 a1> hola UAH ♡

//llenamos a partir del 9º byte hasta el 12º byte incluido con 3 bytes.
buf1.fill("e29880", 9, 12, "hex");
console.log("buf1:", buf1, buf1.toString());
//buf1: <Buffer 68 6f 6c 61 20 55 41 48 20 e2 98 80> hola UAH ☀

buf.write(string[, offset[, length]][, encoding]) Escribe en “buf” de tipo “Buffer” el valor de “string”, tipo cadena partiendo desde una posición determinada del buffer, “offset”, en función de la codificación de caracteres “encoding”. El parámetro “lenght” es el número de bytes a escribir. Si “buf” no contenía suficiente espacio para adaptarse a toda la cadena, sólo una cantidad parcial del string será escrito. No se escribirán los caracteres codificados parcialmente.

buf1.write("bye!");
console.log("buf1:", buf1, buf1.toString());
//buf1: <Buffer 62 79 65 21 20 55 41 48 20 e2 98 80> bye! UAH ☀

buf1.write("e298be", 9, 3, "hex");
console.log("buf1:", buf1, buf1.toString());
//buf1: <Buffer 62 79 65 21 20 55 41 48 20 e2 98 be> bye! UAH ☾

Comparar

buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]]): Compara una region de memoria definida por “buf” o un área dentro de “buf” definida por los desplazamientos “sourceStrat” “sourceEnd” con otra región de memoria definida por “target” o por una área definida dentro de “target” por los desplazamientos “targetStar”, “targetEnd”.

Buffer.compare (buf1, buf2): ídem a llamar buf1.compare(buf2).
devuelve 0 si “target”, (buf1), es igual que “buf”(buf2).
devuelve 1 si “target”, (buf1), debe venir antes “buf” (buf2) al ser ordenado.
devuelve -1 si “target”, (buf1), debe aparecer después de “buf” (buf2) al ser ordenado.

buf.equals(otherBuffer): Devuelve “true” si ambos “Buffer”, “buf y “otherBuffer” tienen exactamente los mismos bytes, de lo contrario false.

const item1 = Buffer.from("Barcelona");
console.log("item1:", item1, item1.toString());
const item2 = Buffer.from("Almería");
console.log("item2:", item2, item2.toString());
const item3 = Buffer.from("Valencia");
console.log("item3:", item3, item3.toString());
const item4 = Buffer.from("Madrid");
console.log("item4:", item4, item4.toString());
const item5 = Buffer.from("Valencia");
console.log("item5:", item5, item5.toString());
/*
item1: <Buffer 42 61 72 63 65 6c 6f 6e 61> Barcelona
item2: <Buffer 41 6c 6d 65 72 c3 ad 61> Almería
item3: <Buffer 56 61 6c 65 6e 63 69 61> Valencia
item4: <Buffer 4d 61 64 72 69 64> Madrid
item5: <Buffer 56 61 6c 65 6e 63 69 61> Valencia*/

console.log("item1 vs item2:", Buffer.compare(item1, item2)); //1
console.log("item2 vs item1:", Buffer.compare(item2, item1)); //-1
console.log("item5 vs item3:", Buffer.compare(item5, item3)); //0

console.log(item1.compare(item2)); //1
console.log(item2.compare(item1)); //-1
console.log(item5.compare(item3)); //0

console.log(item3.equals(item1)); //false
console.log(item3.equals(item5)); //true

//buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])
console.log(item1.compare(item3, 1, 2, 1, 2)); // 0 (a===a)
console.log(item1.compare(item2, 1, 2, 1, 2)); //-1 (l>a)
console.log(item2.compare(item3, 2, 3, 1, 2)); //0 (l===l)
const buf_1 = Buffer.from([0, 1, 2, 3]);
const buf_2 = Buffer.from([2, 3, 0, 1]);
console.log(buf_1.compare(buf_2, 0, 1, 2, 3)); //0 (2===2)
console.log(buf_1.compare(buf_2, 1, 2, 3, 4)); //0 (3===3)
console.log(buf_1.compare(buf_2, 2, 4, 0, 2)); //0 [0,1]==[0,1]
console.log(buf_1.compare(buf_2, 0, 1, 0, 1)); //-1 (2 > 0)
console.log(buf_1.compare(buf_2, 3, 4, 3, 4)); //1 (1 < 3)
const lista = [item1, item2, item3, item4];
console.log("lista:", lista.toString()); //lista: Barcelona,Almería,Valencia,Madrid
console.log("lista ordenada:", lista.sort(Buffer.compare).toString());
/*lista ordenada: Almería,Barcelona,Madrid,Valencia*/

Crear copias de un Buffer o copiar bytes entre Buffers.

buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]]): Copia todos los datos de una región de memoria “buf” o de un fragmento de “buf”, definido por “sourceStart” (desplazamiento desde donde comenzar la copia por defecto valor 0) y “sourceEnd” (desplazamiento para detener la copia, no incluido, por defecto: buf.length) a otra región de memoria, “target” (Buffer), pudiendo comenzar a guardar los datos en “target” a partir de una posición definida por el desplazamiento “targetStart”, por defecto 0.

const bufcopia = Buffer.alloc(3);
buf1.copy(bufcopia, 0, 5, 8); //copiamos en bufcopia el 6º, 7º y 8º byte de buf1
console.log("bufcopia", bufcopia, bufcopia.toString());
//bufcopia <Buffer 55 41 48> UAH

Concatenar varios Buffer

Buffer.concat (list [, totalLength]): Devuelve un nuevo Buffer que es el resultado de concatenar todas las instancias Buffer pasadas en una matriz “list” (tipo Array). Se puede especificar mediante “totalLength” (Integer) la longitud total en bytes de todas las instancias cuando se concatenan en “list”.

Si “totalLength” se proporciona, se fuerza a un entero sin signo. Si la longitud combinada de Buffers en “list” excede totalLength, el resultado se trunca al valor “totalLength”. Si totalLength no se proporciona, se calcula a partir de las instancias Buffer en “list”, ejecutando un bucle adicional para calcularlo.

const sep = Buffer.from(", ");
const lista2 = [item1, sep, item2];
const conc = Buffer.concat(lista2);
console.log(conc, conc.toString()); //<Buffer 42 61 72 63 65 6c 6f 6e 61 2c 20 41 6c 6d 65 72 c3 ad 61> 'Barcelona, Almería'
const conc2 = Buffer.concat(lista2, 10);
console.log(conc2, conc2.toString()); //<Buffer 42 61 72 63 65 6c 6f 6e 61 2c> 'Barcelona,'

Iterar un buffer.

Una instancia “buf” de “Buffer” se pueden iterar empleando el uso de la sintaxis ECMAScript 2015 (ES6) for..of. buf.entries() buf.keys() buf.values().

console.log("iteramos:", item1); //<Buffer 42 61 72 63 65 6c 6f 6e 61>
for (let b of item1) {
  console.log(b, b.toString(16), String.fromCharCode(b));
}
/* 66 '42' 'B'
97 '61' 'a'
114 '72' 'r'
99 '63' 'c'
101 '65' 'e'
108 '6c' 'l'
111 '6f' 'o'
110 '6e' 'n'
97 '61' 'a'
*/
for (let par of item1.entries()) {
  console.log(par);
}
//[ 0, 66 ] [ 1, 97 ] [ 2, 114 ] [ 3, 99 ] [ 4, 101 ] [ 5, 108 ] [ 6, 111 ] [ 7, 110 ] [ 8, 97 ]
for (let valor of item1.values()) {
  console.log(valor);
}
//66 97 114 99 101 108 111 110 97

Manipular buffers

buf.slice([start[, end]]): Devuelve una instancia de “Buffer” que hace referencia a la misma memoria que el original, pero acotada por los índices “start”, entero donde debe comenzar el nuevo Buffer por defecto valor 0) y “end” donde debe terminar el nuevo “Buffer” (no incluido) por defecto buf.length.

const sliceItem1 = item1.slice(5, 9);
console.log(sliceItem1.toString()); //lona
//item1 y sliceItem1 comparten memoria
sliceItem1.fill("*"); //modifica memoria original
console.log(item1.toString()); //Barce****

Ejemplos empleando el módulo Buffer.

A continuación unos ejemplos simples del uso de Buffer.

Listado de caracteres con puntos de código utf8.

En el archivo se encuentra un script con un algoritmo que permite mostrar por pantalla un carácter junto con su representación binaria y hexadecimal siguiendo la codificación UTF-8. El algoritmo solo permite representar los caracteres que pueden expresarse hasta con 3 bytes de longitud, empezando desde la posición decimal 32 hasta la posición decimal 65535.

Código disponible en github unicode_utf8.js

const buf3 = Buffer.alloc(3);
const buf2 = Buffer.alloc(2);
const buf = Buffer.alloc(1);
console.log("\nUTF8 (3 bytes) dese 0000 'Basic Latin' .... FFFF 'Specials'\n");
for (let a = 32; a <= 65535; a++) {
  let utf8;
  let hex;
  let decimal;
  let binario;
  if (a <= 127) {
    //solo empleamos un byte buf
    buf[0] = a; //ascii 7 bits (1 byte)
    hex = buf.toString("hex");
    cpUnicode = "U00" + a.toString(16).toUpperCase();
    utf8 = buf.toString();
    decimal = buf.readUInt8();
  }

  if (a >= 128 && a <= 2047) {
    //(7FF hex) entonces UTF-8 es 2 bytes.
    buf2[0] = 192 + a / 64;
    buf2[1] = 128 + (a % 64);
    hex = buf2.toString("hex");
    cpUnicode = "U00" + a.toString(16).toUpperCase();
    utf8 = buf2.toString();
    decimal = `[${buf2.readUInt8(0)} ${buf2.readUInt8(1)}]`;
    binario = `[${buf2.readUInt8(0).toString(2)} ${buf2
      .readUInt8(1)
      .toString(2)}]`;
  }

  if (a >= 2048 && a <= 65535) {
    // (FFFF hex) entonces UTF-8 tiene longitud de 3 bytes.
    buf3[0] = 224 + a / 4096;
    buf3[1] = 128 + ((a / 64) % 64);
    buf3[2] = 128 + (a % 64);
    hex = buf3.toString("hex");
    bin = hex.toString(2);
    cpUnicode = "U" + a.toString(16).toUpperCase();
    utf8 = buf3.toString();
    decimal = `[${buf3.readUInt8(0)} ${buf3.readUInt8(1)} ${buf3.readUInt8(
      2
    )}]`;
    binario = `[${buf3.readUInt8(0).toString(2)} ${buf3
      .readUInt8(1)
      .toString(2)} ${buf3.readUInt8(2).toString(2)}]`;
  }
  let print = `Unicode: ${cpUnicode}; bytes UTF8(hex ${hex}, dec ${decimal}); char:${utf8} ${binario}`;
  let control = `Unicode: ${cpUnicode}; bytes UTF8(hex ${hex}, dec ${decimal}); <ctrl>`;
  console.log(a < 127 || a > 159 ? print : control);
}

Extraer información del flujo de datos de un archivo png.

En este ejemplo se trabajará con los datos leídos de un archivo png (Portable Network Graphics) que han sido almacenados en memoria. Para ello es necesario conocer la estructura del flujo de datos que está asociada a este tipo de archivo que viene reflejado en la norma “Functional specification. ISO/IEC 15948:2003 (E)” que se puede consultar en REC-PNG-20031110 a continuación se exponen algunos conceptos necesarios para entender el posterior ejemplo.

El flujo de datos PNG consiste en una firma PNG formada por 8 bytes con los siguientes valores en hexadecimal: 89 50 4E 47 0D 0A 1A 0A, seguida de una secuencia de fragmentos. Cada fragmento de la secuencia está formado por tres o cuatro campos: un campo “LENGTH” (entero sin signo de 4 bytes) que proporciona el número de bytes del contenido del campo “DATA” del correspondiente fragmento. Un campo “TYPE” formado por 4 bytes que definen el tipo de fragmento. Un campo “DATA” con un número de bytes de datos apropiados para el tipo de fragmento y por último un campo “CRC” de 4 bytes calculado a partir de los anteriores bytes del fragmento, sin incluir el campo de longitud.

Un flujo de datos PNG válido comenzará con la firma PNG, seguida inmediatamente por un fragmento IHDR (encabezado de imagen), luego uno o más fragmentos IDAT, y finalizará con un fragmento IEND (Image trailer). Solo se permite un fragmento IHDR y un fragmento IEND en un flujo de datos PNG. En el ejercicio vamos a emplear solo los fragmentos IHDR e IEND y la firma PNG.

El campo “TYPE” del fragmento “IHDR” siempre contiene los siguientes valores decimales 73 72 68 82 a continuación, su campo “DATA”, comienza con 4 bytes reservados para la anchura y continúa con otros 4 bytes reservados para la altura, después hay una serie de bytes reservados para otras propiedades. Anchura y altura dan las dimensiones de la imagen en píxeles. Son enteros sin signo de cuatro bytes PNG.

El campo “TYPE” del fragmento “IEND”, que marca el final de la transmisión de datos PNG, siempre contiene 4 bytes con los siguientes valores decimales 73 69 78 68 el campo DATA de este fragmento siempre está vacío.

Para leer el archivo “png” y almacenar el contenido en un buffer se va a usar el método “readFileSync” del módulo “fs” (file system) que se explicará en próximos capítulos. Una vez obtenido el buffer de datos, se analizará para determinar si los datos corresponden a un archivo “png”. En el caso de ser un archivo “png”, se accederá a los fragmentos IHDR (para extraer, su campo TYPE y la anchura/altura de la imagen) e IEND (para extrer el valor del campo TYPE) mostrando los datos por pantalla. Por último se codificará el contenido del buffer de datos de todo el archivo en una cadena, usando como codificación base64. En ocasiones puede ser útil el poder incrustar los datos de una imagen dentro del archivo HTML, sin tener que poner una dirección externa, esto se hace mediante DATA URIs especificando los bits del fichero de la imagen en base64, por ejemplo, cualquier navegador web puede interpretar la siguiente URI: “data: image/png; base64,” + “Cadena del png en base64”.

Código disponible en github png.js

const fs = require("fs");
const firmaPng = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]); //firma del PNG
const fragmentoIHDR = Buffer.from([73, 72, 68, 82]); //"IHDR" Buffer.from(array de enteros)
const fragmentoIEND = Buffer.from([73, 69, 78, 68]); //"IEND" Buffer.from(array de enteros)
function esPNG(buffer) {
  //comparamos los 8 primeros bytes de un Buffer con la firma png
  if (buffer.compare(firmaPng, 0, 8, 0, 8) === 0) {
    //si son iguales
    const Type = Buffer.alloc(4); //4 bytes para el contenido TYPE de IHDR
    //Después de 8 bytes de firma viene el fragmento IHDR
    //el campo TYPE de IHDR de empieza en la posicion 12 son 4 bytes
    buffer.copy(Type, 0, 12, 16); //copiamos el contenido de TYPE en Type
    if (!Type.equals(fragmentoIHDR)) {
      // si no coincide con "IHDR"
      throw new TypeError("png no valido");
    }
    console.log("encontrado fragmento", Type.toString("utf8"));
    //Extraemos contenido de las posiciones correspondientes al campo type de IEND
    const fin = buffer.toString("utf8", buffer.length - 8, buffer.length - 4);
    if (fin === fragmentoIEND.toString("utf8")) {
      // si coincide con "IEND"
      console.log("encontrado fragmento", fin);
    }
    return true; //es un png
  }
}
/*Partiendo de los datos del buffer creamos una cadena usando base64 */
function encode_base64(buffer) {
  let png_base64 = buffer.toString("base64");
  return png_base64;
}

function dimension(buffer) {
  return {
    //4 bytes después de TYPE de frag IHDR
    anchura: buffer.readUInt32BE(16), //Lee 32 bits sin signo (Big Endian)
    altura: buffer.readUInt32BE(20)
  };
}

//Lee de forma síncrona todo el contenido de un archivo.
const imgData = fs.readFileSync("happy.png");
if (esPNG(imgData)) {
  //si es png muestra dimensiones y uri de datos
  console.log(dimension(imgData));
  console.log("data:image/png;base64,", encode_base64(imgData));
}

Introducción a Buffer en JavaScript

jorgeabad — Wed, 05 Jul 2023 17:33:47 +0000

Datos binarios.

Para poder tratar los flujos TCP, leer y escribir en el sistema de
archivos, es necesario tratar con flujos de datos que son puramente
binarios. Los datos, como regla general, se presentan internamente como
octetos, (8 bits). Un octeto o byte es una pequeña unidad de datos con
un valor numérico entre 0 y 255 (256 valores). Los valores numéricos se
pueden representar en la notación normal (decimal), pero también se
pueden usar otras presentaciones, como la octal (base 8) o la
hexadecimal (base 16).

Búfer. ArrayBuffer en JavaScript.

Un búfer es una región de almacenamiento ubicada en la memoria física
que es utilizada para almacenar temporalmente una cierta cantidad de
datos, octetos, mientras se mueven de un lugar a otro. En Node.js esta
memoria intermedia corresponde a memoria bruta asignada fuera del montón
(“heap”) de V8.

En JavaScript para representar un búfer genérico se usa el objeto
“ArrayBuffer”, que en definitiva es un área de memoria reservada donde
se almacenará un conjunto datos binarios. Esta área es de tamaño fijo y
no puede incrementarse ni reducirse dinámicamente. No se puede trabajar
directamente con esta área reservada, ya que no existen métodos o
funciones que sean capaces de acceder directamente al “ArrayBuffer”,
para poder trabajar y acceder a esos datos ubicados en memoria, desde
JavaScript puro, es necesario utilizar el objeto “TypedArray” o el
objeto “DataView” que funcionan como una vista de los datos contenidos
en un “ArrayBuffer”.

Estas matrices tipadas, son similares a un “array” de enteros que no
puede redimensionarse. El “tipo” se refiere a una “vista” concreta de
ese búfer como pueden ser: números enteros sin signo de 8 bits, números
enteros de 32 bits, coma flotante de 64 bits, etc.

“Int8Array”: entero de 8-bit con signo
“Uint8Array”: entero de 8-bit sin signo
“Uint8ClampedArray”: entero de 8-bit sin signo restringido a valores entre 0 y 255
“Int16Array”: 2 enteros de 16-bit con signo
“Uint16Array”: 2 enteros de 16-bit sin signo
“Int32Array”: 4 enteros de 32-bit con signo
“Uint32Array”: 4 enteros de 32-bit sin signo
“Float32Array”: 4 coma flotante de 32-bit
“Float64Array”: 8 coma flotante de 64-bit

Sobre un mismo “ArrayBuffer” podemos establecer una o más vistas de
matrices tipadas. Cada una de las matrices trabajará sobre el mismo
búfer, y cada una de ellas tratará los datos según el tipo de datos que
tienen definidos. Hay que tener en cuenta, cuando se almacena más de un
byte, si el entorno es BE (Big-endian) o LE (Little-endian). LE
considera el byte menos significativo en primera posición, en BE el byte
más significativo se almacena en primera posición.

En el siguiente ejemplo creamos un “ArrayBuffer” de 2 bytes y creamos
dos matrices con tipo sobre el mismo búfer de datos, una de enteros de 8
bits sin signo y otra de enteros de 16 bits sin signo.

Codigo disponible en el archivo buffer1.js GitHub

Usamos la vista de un entero 8 bits, para asignar los valores al primer
y segundo byte. En el primer octeto guardamos el valor 255 en binario
‘11111111’ en el segundo byte guardamos el valor 128 en binario
‘10000000’.

Cuando se visualiza el valor contenido en el “ArrayBuffer” desde la
vista de 16 bits, en un entorno LE, considera que el primer byte es el
menos significativo y el segundo byte el más significativo por lo el
valor obtenido es el siguiente 1000000011111111 que es 33023 en decimal.
En un entorno BE el valor decimal sería 65408 en binario
1111111110000000.

const memoria = new ArrayBuffer(2);
const vista8 = new Uint8Array(memoria);
const vista16 = new Uint16Array(memoria);
vista8[0] = 255; //11111111
vista8[1] = 128; //10000000
console.log(vista8); //Uint8Array [ 255, 128 ]
//LE byte menos significativo 1º
console.log(vista16, vista16[0].toString(2)); //Uint16Array [ 33023 ] '1000000011111111'

Si modificamos el valor desde la vista de 16 evidentemente también
cambia los valores para la vista de 8. Si asignamos el valor 65408 en
binario 1111111110000000 se puede observar cómo ha cambiado la vista de
8, al ser un entorno LE el byte menos significativo “10000000” (128
decimal) se coloca en primera posición el más significativo en segunda
posición “11111111” (255 en decimal). Si asignamos cualquier otro valor
desde la vista de 16, por ejemplo 1000 pasaría lo mismo.

vista16[0] = 65408; //1111111110000000
console.log(vista16); //Uint16Array [ 65408 ]
console.log(vista8, vista8[0].toString(2),vista8[1].toString(2)); 
//Uint8Array [ 128, 255 ] '10000000' '11111111'

vista16[0] = 1000; //0000001111101000
console.log(vista16); //Uint16Array [ 1000 ]
console.log(vista8, vista8[0].toString(2),vista8[1].toString(2)); 
//Uint8Array [ 232, 3 ] '11101000' '11'

Codificación y juego de caracteres.

Como se ha explicado anteriormente cada octeto de información contiene
un valor numérico. Para poder representar los caracteres, hay que
establecer una correspondencia entre el valor numérico del octeto y un
carácter en función de alguna tabla de mapeo (codificación). Un
repertorio de caracteres especifica una colección de caracteres,
como "a", "!" Y "ä". Los códigos de carácter son códigos numéricos
definidos para los caracteres de un repertorio. Una codificación de
caracteres define cómo las secuencias de códigos numéricos son
asignadas a las secuencias de octetos.

Codificación de caracteres. Estándares.

ASCII 7 bits

Una de las primeras codificaciones en aparecer fue ASCII (American
Standard Code for Information Interchange). La codificación, ASCII usa 7
bits por lo que dispone de 128 valores posibles que van desde el 0000000
a 1111111, cada número de código se presenta como un octeto con el mismo
valor y representa un carácter. ASCII tiene espacio suficiente para
todas las minúsculas y mayúsculas de las letras latinas y para cada
dígito numérico, signos de puntuación comunes, espacios y otros
caracteres de control. Empieza en el código 32 (asignado al espacio en
blanco) y termina en el 126 (asignado a el carácter tilde ~). Las
posiciones del 0 a 31 y 127 están reservadas para códigos de control. La
mayoría de los códigos de caracteres actualmente en uso contienen ASCII
como su subconjunto en algún sentido, los octetos que contienen valores
del 128 al 255 no se usan en ASCII.

Codificaciones de 8 bits

Mediante 8 bits se puede representar hasta el número 255 (256 valores),
por lo que se puede tener un conjunto de caracteres más amplios, ASCII
solo asigna hasta 127, los otros valores del 128 a 255 son de repuesto,
aprovechando estos valores de repuesto aparecieron diferentes códigos de
caracteres que fueron creados para adaptarse a los diferentes idiomas.
Estos código de caracteres son una extensión del ASCII, los más
importantes son los pertenecientes a la familia ISO 8859 y el juego de
caracteres de Windows. Los códigos ISO 8859 amplían el repertorio ASCII
de diferentes maneras con diferentes caracteres especiales utilizados en
diferentes idiomas y culturas. Las posiciones del código 0 - 127
contienen el mismo carácter que en ASCII, las posiciones 128 - 159 no se
usan (reservadas para los caracteres de control), y las posiciones 160 -
255 son la parte variable, utilizada de manera diferente en diferentes
miembros de la familia ISO 8859. ISO 8859-1 alias “Latín 1” contiene
varios caracteres acentuados y otras letras necesarias para escribir
idiomas de Europa occidental y algunos caracteres especiales. El juego
de caracteres de Windows, es similar a la familia ISO 8859, la principal
diferencia es que algunas de las posiciones del rango 128 a 159 se
asignan a caracteres imprimibles, como las comillas dobles, comillas
simples etc., en el rango de 160-255 se mantienen las mismas
asignaciones de caracteres que en ISO 8859 aunque no siempre, existiendo
así diferentes páginas de código (CP), que difieren del estándar ISO
8859 correspondiente.

ISO 10646, Unicode y UTF-8.

Las anteriores codificaciones de caracteres eran limitadas y no podían
contener suficientes caracteres para abarcar todos los idiomas del
mundo, además entraban en conflicto, pues dos codificaciones podrían
usar el mismo número o código para dos caracteres diferentes, o usar
números diferentes para el mismo carácter. Si se quiere codificar todos
los caracteres del mundo asignando a cada uno un código único no es
suficiente con los 256 valores que se pueden almacenar en un byte, para
su codificación es necesario un código multibyte.

Con este objetivo nacieron paralelamente la norma ISO 10646 y el
estándar Unicode (consorcio Unicode), que definen el Conjunto de
Caracteres Universales, (UCS), que contiene los caracteres necesarios
para representar prácticamente todos los idiomas conocidos, también
cubre una gran cantidad de símbolos gráficos, tipográficos, matemáticos
y científicos. UCS es un superconjunto de todos los demás estándares de
conjunto de caracteres. UCS y Unicode al necesitar codificación
multibyte abarca dos cosas: un conjunto de caracteres y un conjunto de
codificaciones.

Un conjunto de caracteres:

Tablas de códigos que asignan números enteros a los caracteres. UCS le asigna a cada carácter un nombre o
“punto de código” que consiste en un número hexadecimal que representa
el valor UCS o Unicode y que suele estar precedido por la cadena "U +".
Los caracteres UCS que van desde “U+0000” a “U+007F” son idénticos a los
de US-ASCII y el rango de “U+0000” a “U+00FF” es idéntico al ISO 8859-1
(Latin-1). Además proporciona códigos para signos diacríticos y permite
que ciertas secuencias de caracteres también se pueden representar como
un solo carácter, llamado carácter pre compuesto (o compuesto, o
carácter descomponible). Por ejemplo, el carácter "ñ" puede codificarse
como el único punto de código U+00F1 "ñ" o como una secuencia compuesta
del carácter base U+006E "n" seguido del carácter no espaciador U+0303
“~”.

Los caracteres más comúnmente utilizados, incluidos todos los que se encuentran en los principales estándares de codificación anteriores, se han colocado en un primer plano (0x0000 a 0xFFFD), 64K (2^16^ ) puntos de código, que se llama plano multilingüe básico (BMP) o Plano 0.

Un conjunto de codificaciones:

Para poder codificar todos los
caracteres de todos los idiomas utilizando varios bytes, es decir,
asignar una secuencia de bytes, “valor de código”, a cada carácter o
punto de código, existen varias alternativas.

Las dos codificaciones más obvias almacenan los caracteres Unicode como
una secuencia de bytes de ancho fijo de 2 o 4 bytes. Los términos
oficiales para estas codificaciones son UCS-2 y UCS-4, respectivamente.
A menos que se especifique lo contrario, el byte más significativo es el
primero (Big endian). Un archivo ASCII se puede transformar en un
archivo UCS-2 simplemente insertando un byte “0x00” delante de cada byte
ASCII. Si queremos tener un archivo UCS-4, tenemos que insertar tres
bytes de “0x00” antes de cada byte ASCII.

Para poder usar un ancho variable se creó el formato de transformación
Unicode (UTF) o "formato de transformación UCS” que mediante un mapeo
algorítmico asigna a cada punto de código Unicode una secuencia de bytes
única. Debido a que el punto de código tiene 21 bits, y a que los
ordenadores transfieren datos en múltiplos de 8 bits hay tres posibles
modos de expresar Unicode:

Usando una unidad de código de 32 bits, cada carácter se representa con 4 bytes (UTF-32).
Usando una o dos unidades de código de 16 bits, cada carácter se representa con 2 bytes como mínimo o 4 como máximo (UTF-16).
Usando de una a cuatro unidades de código de 8 bits cada carácter se representa con 1 byte como mínimo pudiendo llegar a 4 bytes como máximo (UTF-8).

UCS-4, UTF-32, UCS-2, UTF-16 en cierta medida son ineficientes. Las
computadoras intercambian muchas cadenas, y una gran mayoría de esas
cadenas solo usan caracteres ASCII que se pueden almacenar con un solo
byte, ocho bits. Es extremadamente ineficiente usar 4 bytes para
almacenar un carácter ASCII. Además estos formatos de codificación al
usar más de un byte, han de hacer frente al problema de la “endianidad”
ya que pueden almacenarse en memoria con el byte más significativo (MSB)
primero (BE) o el último (LE), lo que puede provocar que cuando se
intercambian datos, los bytes que aparecen en el orden "correcto" en el
sistema de envío, pueden aparecer como desordenados en el sistema
receptor. En algunos casos hay que usar una firma que define el orden de
los bytes y el formulario de codificación, (marca de orden de byte BOM),
que consiste en el código de carácter U+FEFF al comienzo de una
secuencia de datos.

UTF-8

UTF-8 es una codificación de longitud variable en la que cada punto de
código UCS se codifica utilizando 1, 2, 3 o 4 bytes según sea necesario
por lo tanto es más eficiente para caracteres ASCII, por otro lado no
presenta el problema de “endianidad” al tener siempre el mismo orden de
bytes.

UTF-8 tiene las siguientes propiedades:

Los caracteres UCS U+0000 a U+007F (ASCII) están codificados simplemente como 1 byte 0x00 a 0x7F (compatibilidad ASCII).
Todos los caracteres de UCS > U+007F (127 decimal) están codificados como una secuencia de varios bytes, cada uno de los cuales tiene el bit más significativo establecido. Por lo tanto, ningún byte ASCII (0x00-0x7F) puede aparecer como parte de ningún otro carácter.

A continuación se muestra las reglas del algoritmo para la codificación
utf-8, partiendo de su punto de código se emplearán 1, 2, 3 o 4 bytes.
Las posiciones de los bits “xxx…” se llenan con los bits del número del
código de carácter en representación binaria, teniendo en cuenta que el
extremo derecho de los bits x será el bit menos significativo.

U+0000 - U+007F (0-127): 0xxxxxxx (1byte)
U+0080 - U+07FF (128-2047): 110xxxxx 10xxxxxx (2bytes)
U+0800 - U+FFFF (2048-65535): 1110xxxx 10xxxxxx 10xxxxxx (3bytes)
U+10000 - U+1FFFFF (65536-2097151): 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx (4bytes)

Si el primer bit de un byte es un "0", los 7 bits restantes del byte
contienen uno de los 128 caracteres originales ASCII de 7 bits.

El primer byte de una secuencia multibyte que representa un carácter no
ASCII siempre está en el rango de 0xC0 (192) a 0xFD (253) e indica de
cuántos bytes está compuesta la secuencia en función de los bits con
valor “1”.

Todos los bytes adicionales en una secuencia multibyte están en el rango de 0x80 (128) a 0xBF (191).

Por ejemplo el carácter “ñ” tendría el código número 241 (decimal) que es F1 en hexadecimal y en binario 11110001, su código Unicode por lo tanto sería U00F1, para su codificación se usaran 2 bytes, “110xxxxx 10xxxxxx”, sustituyendo las x por el valor de su código, 241, en binario el resultado sería 110000*11* 10*110001* equivalente a c3b1 en hexadecimal, y a [195, 177] en decimal.

Como hemos mencionado antes, también podríamos representar la letra “ñ” como una secuencia compuesta del carácter base U+006E "n" seguido del carácter no espaciador U+0303“~” que pertenece al bloque marcas diacríticas que van desde la U+0300 a U+036F. Para representarlo necesitaríamos 3 bytes:

1 byte para la letra “n” que se corresponde con el condigo número 110 en decimal que es 6E hexadecimal y en binario 01101110
2 bytes para la marca diacrítica “~” que se corresponde con el código número 771 en decimal que se corresponde con 0x303 en hexadecimal y en binario 1100000011 si lo pasamos a la codificación UTF8 110xxxxx 10xxxxxx tendríamos 2 bytes con los valores 1100*1100* 10*000011* que equivalen a cc83 en hexadecimal y a [204, 131] en decimal.

A continuación, usaremos JavaScript para ejemplificar lo explicado y relacionarlo con los ArrayBuffer, usaremos el objeto incorporado TextDecoder que nos permite leer el texto de un conjunto de datos binarios y convertirlo en un dato de tipo string de JavaScript, dados un búfer y la codificación, si no se especifica la codificación por defecto será utf-8. También usaremos el método TextEncoder que toma un String como una entrada y devuelve una secuencia de bytes con codificación UTF-8 siempre devuelve un tipo Uint8Array. A modo de curiosidad también usaremos el método codePointAt(pos)de String, que nos permite obtener el punto de código del valor Unicode del carácter que está situado en una posición (pos) determina de la cadena. También conviene señalar que en JavaScript, los literales de cadena se pueden expresar mediante su respectivo punto de código Unicode en codificación UTF-16 para ello se ha de utilizar la secuencia de escape Unicode, la sintaxis general es\uXXXX, donde X denota cuatro dígitos hexadecimales.

Codigo disponible en el archivo EncodingArrayBuffer.js GitHub

const encoder = new TextEncoder()
const decoder = new TextDecoder()

console.log('ñ'.codePointAt(0));//241
//dec=241 hex=F1 bin=11110001 => utf-8 (11000011 10110001 -> c3b1 -> 2bytes [195, 177]
const str1u8 = new Uint8Array([195,177]);//Generamos un búfer con los datos oportunos.
console.log(str1u8)//[195,177]
let str1 = decoder.decode(str1u8)//decodificamos el bufer
console.log(str1)//ñ
console.log(str1.length);//1
console.log(str1.codePointAt());//241

let string1 = '\u00F1';
console.log(string1);//ñ
console.log(string1===str1);//true

const vista = encoder.encode(str1)
console.log(vista);//[195,177]

const ene='n'
const diacritica='̃'
console.log(ene.codePointAt(0));//110
//dec=110 hex=6E bin=01101110 => utf-8 -> 01101110 -> 6E -> 1 byte [110]
console.log(diacritica.codePointAt(0));//771
//dec=771 hex=0x303 bin=1100000011 => utf-8 (11001100 10000011-> cc83 -> 2 bytes [204, 131].
const u8 = new Uint8Array([110,204,131]);//Generamos un búfer con los datos oportunos.
console.log(u8)//[110,204,131]
let str2 = decoder.decode(u8)//decodificamos el bufer
console.log(str2)//ñ
console.log(str2.length);//2 hemos usado dos caracteres
//Hallamos el punto de código de cada caracter.
console.log(str2.codePointAt(0));//110
console.log(str2.codePointAt(1));//771

let string2 = '\u006E\u0303';
console.log(string2);//ñ
console.log(string2===str2);//true

const vista2 = encoder.encode(str2)
console.log(vista2);//[110,204,131]

Notas adicionales

Como hemos comprobado antes para el caso
del carácter “ñ” un punto de código, o una secuencia de puntos de código,
pueden representar el mismo carácter abstracto, esta información hay que
tenerle en cuenta a la hora de comparar cadenas y de operar con ellas, debido a
que los puntos de código son diferentes por lo que la comparación de cadenas no
los tratará como iguales, aunque visualmente lo parezcan, debido a que la
cantidad de puntos de código en cada versión es diferente por lo que las
cadenas tienen diferentes longitudes. Lo podemos comprobar en el siguiente
código.

//comparamos las dos cadenas string1='\u00F1' y string2='\u006E\u0303'
console.log(string1 === string2); //false
console.log(string1.length);      // 1
console.log(string2.length);      // 2

Para resolver el anterior problema se puede usar el método normalize() de string, que permite convertir una cadena en una forma normalizada común para todas las secuencias de puntos de código que representan los mismos caracteres.

Se puede usar la normalización basada en la equivalencia canónica: dos secuencias de puntos de código tienen equivalencia canónica si representan los mismos caracteres abstractos y siempre
deben tener la misma apariencia visual y comportamiento. Para ello, podemos usar string.normalize([forma]) donde el argumento “forma” puede ser entre otros:

“NFC”: Normalization Form Canonical Composition. Forma canónica compuesta
“NFD”: Normalization Form Canonical Decomposition. Forma canónica descompuesta

Para producir una forma de la cadena que será la misma para todas las cadenas canónicamente equivalentes. Apliquemos las normalizaciones a las dos representaciones del carácter “ñ”

//Convertimos string1 '\u00F1' a su forma descompuesta
string1 = string1.normalize('NFD');//ñ
console.log(string1 === string2); // true
console.log(string1.length);      // 2
console.log(string2.length);      // 2
console.log(string1.codePointAt(0).toString(16)); //6E
console.log(string1.codePointAt(1).toString(16)); //303

//Convertimos string2 y string1 \u006E\u0303 a sus formas compuesta
string1 = string1.normalize('NFC');//ñ
string2 = string2.normalize('NFC');//ñ
console.log(string1 === string2);// true
console.log(string1.length);// 1
console.log(string2.length);//1
console.log(string2.codePointAt(0).toString(16)); //f1
console.log(string1.codePointAt(0).toString(16)); //f1

Por ejemplo si quisiéramos obtener una cadena libre de marcas diacríticas, tildes, diéresis podríamos normalizarla a su forma descompuesta y a continuación eliminar las marcas diacríticas.

let cadenaDiacriticos ='áéíóúñüÁÉÍÓÚnaeiou'
console.log(cadenaDiacriticos.length)//18
//normalizamos forma descopmuesta y quitamos marcas diacríticas que van desde la `U+0300` a `U+036F`
cadenaDiacriticos=cadenaDiacriticos.normalize('NFD')
console.log(cadenaDiacriticos.length)//30
cadenaDiacriticos=cadenaDiacriticos.replace(/[\u0300-\u036f]/g,"");//aeiounuAEIOUnaeiou
console.log(cadenaDiacriticos)////aeiounuAEIOUnaeiou
console.log(cadenaDiacriticos.length)//18

Reto JS. Organizando bolas en urnas con JS

jorgeabad — Sun, 02 Jul 2023 18:50:09 +0000

Organizando bolas en urnas con JS

Artículo en Organizando bolas en urnas con JS
Código del desafío en GitHub

Todos los desafíos JS en Desafíos de Programación en JavaScript

Dado un conjunto de contenedores numerados del 0 al n, cada uno de ellos contiene un número de bolas que puede ser del tipo 0 al n. En otras palabras, hay la misma cantidad de tipos de bolas que de contenedores. Por ejemplo, consideremos la siguiente tabla:

Contenedor/Tipo	0	1	2
0	2	3	1
1	4	0	1
2	1	3	3

Tenemos 3 contenedores (denominados 0, 1 y 2) y 3 tipos de bolas con números diferentes (0, 1, 2).

El contenedor 0 tiene 6 bolas: 2 bolas del tipo 0, 3 bolas del tipo 1 y 1 bola del tipo 2.
El contenedor 1 tiene 5 bolas: 4 bolas del tipo 0 y 1 bola del tipo 2.
El contenedor 2 tiene 7 bolas: 1 bola del tipo 0, 3 bolas del tipo 1 y 3 bolas del tipo 2.

El objetivo es clasificar las bolas de manera que se cumplan las siguientes condiciones:

Cada contenedor solo puede contener bolas del mismo tipo.
No puede haber bolas del mismo tipo en diferentes contenedores.

Para lograr esta clasificación, solo se permite realizar la operación de intercambio, es decir, se pueden intercambiar dos bolas ubicadas en diferentes contenedores. Esta operación se puede repetir tantas veces como sea necesario.

Desafío:

Completar la función organizingContainers que cumple con los siguientes requerimientos:

Entrada:

int container[n][m]: una matriz bidimensional de enteros que representa el número de bolas de cada tipo en cada contenedor. Por ejemplo:

const matriz1 = [  
  [2, 3, 1],
  [4, 0, 1],
  [1, 3, 3]
];

Salida:

String: 'Possible' o 'Impossible'. Devuelve 'Possible' si es posible que cada contenedor solo contenga bolas del mismo tipo y no haya dos bolas del mismo tipo en contenedores diferentes, es decir, si es posible almacenar cada tipo de bola en un contenedor. Devuelve 'Impossible' si no es posible realizar esa clasificación.

El programa en la terminal tendrá el siguiente formato de entrada:

Se solicitará el número entero de consultas a realizar, llamémolos q.
Para cada consulta:
- Se debe ingresar un número entero que representa el número de contenedores (filas) y tipos de bolas (columnas).
- Luego, cada una de las siguientes n líneas contendrá n enteros separados por espacios que describen la fila containers[i].

Para cada consulta, imprime "Possible" en una nueva línea si se pueden clasificar las bolas de acuerdo con las condiciones mencionadas anteriormente para la matriz dada. De lo contrario, imprime "Impossible".

Ejemplo:

Supongamos que queremos realizar 3 consultas. Para cada consulta, mostraremos una tabla explicativa y cómo se representaría en la terminal:

Consulta 1:

Contenedor/Tipo	0	1	2
0	1	3	1
1	2	1	2
2	3	3	3

En la terminal:

1 3 1
2 1 2
3 3 3

Consulta 2:

Contenedor/Tipo	0	1	2
0	0	2	1
1	1	1	1
2	2	0	0

En la terminal:

0 2 1
1 1 1
2 0 0

Consulta 3:

Contenedor/Tipo	0	1
0	0	2
1	1	1

En la terminal:

0 2
1 1

Ejemplo de entrada para las tres consultas:

3 // q = 3 indica tres consultas
3 // n = 3 matriz 3x3 (primera consulta)
1 3 1
2 1 2
3 3 3
3 // n = 3 matriz 3x3 (segunda consulta)
0 2 1
1 1 1
2 0 0
2 // n = 2 matriz 2x2 (tercera consulta)
0 2
1 1

Ejemplo de salida en la terminal:

Impossible
Possible
Impossible

Solución:

Para clasificar las bolas, solo se permite la operación de intercambio, es decir, se pueden intercambiar dos bolas ubicadas en diferentes contenedores. Con base en esta premisa, cada contenedor tiene una capacidad fija que puede ser diferente o igual a la de los demás contenedores. Por lo tanto, para asegurar que cada contenedor contenga solo bolas del mismo tipo, es necesario que la cantidad de bolas de cada tipo, T0, T1,... Tn, coincida con las capacidades de los contenedores, C0, C1,... Cn, para poder colocar las bolas de cada tipo en el contenedor que tenga la capacidad adecuada.

Por ejemplo para las tres consultas anteriores miremos las siguientes tablas donde TC representa la capacidad de cada contenedor y TB representa el númro de bolas de cada tipo.

Consulta 1:

Contenedor/Tipo	0	1	2	TC
0	1	3	1	5
1	2	1	2	5
2	3	3	3	9
TB	6	7	6

Contenedor	0	1	2
Capcidad	5	5	9

Tipo	0	1	2
Cantidad	6	7	6

La cantidad de bolas de cada tipo no coincide con la capacidad de los contenedores. Por lo que la clasificación es imposible.

Consulta 2:

Contenedor/Tipo	0	1	2	TC
0	0	2	1	3
1	1	1	1	3
2	2	0	0	2
TB	3	3	2

Contenedor	0	1	2
Capcidad	3	3	2

Tipo	0	1	2
Cantidad	3	3	2

La cantidad de bolas de cada tipo coincide con las capacidades de los contenedores. Por lo que la clasificación es posible.

Consulta 3:

Contenedor/Tipo	0	1	TC
0	0	2	2
1	1	1	2
TB	1	3

Contenedor	0	1
Capcidad	2	2

Tipo	0	1
Cantidad	1	3

La cantidad de bolas de cada tipo no coincide con la capacidad de los contenedores. Por lo que la clasificación es imposible.

Una posible solución es la siguiente:

Generar un array de n elementos con las capacidades de cada contenedor.
Generar un array de n elementos con las cantidades de cada tipo de bola.
Ordenar ambos arrays.
Si los arrays son idénticos, devolver "Possible"; de lo contrario, devolver "Impossible".

function organizingContainers(matriz) {

  // Calcular sumatorios por fila utilizando map y reduce
  const contenedores = matriz.map(fila => fila.reduce((suma, elemento) => suma + elemento, 0));

  // Calcular sumatorios por columna utilizando reduce y map
  const tipos = matriz.reduce((columnas, fila) =>
    fila.map((elemento, indice) => (columnas[indice] || 0) + elemento), []);

  // Ordenar los arrays de menor a mayor
  contenedores.sort((a, b) => a - b);
  tipos.sort((a, b) => a - b);

  // Verificar si los arrays son iguales
   return JSON.stringify(contenedores) === JSON.stringify(tipos)?'Possible':'Impossible';
}

Ahora, veamos en detalle cómo se utilizan map y reduce en cada parte de la función:

Cálculo de sumatorios por fila utilizando map y reduce:

const contenedores = matriz.map(fila => fila.reduce((suma, elemento) => suma + elemento, 0));

map se utiliza para iterar sobre cada fila de la matriz.
reduce se utiliza en cada fila para calcular la suma de sus elementos.
El valor inicial de reduce se establece en 0 (0) para comenzar la suma desde cero en cada fila.
El resultado de reduce se asigna a la matriz contenedores, que almacenará los sumatorios por fila.

Cálculo de sumatorios por columna utilizando reduce y map:

const tipos = matriz.reduce((columnas, fila) =>
  fila.map((elemento, indice) => (columnas[indice] || 0) + elemento), []);

reduce se utiliza para iterar sobre cada fila de la matriz.
map se utiliza en cada fila para acceder a cada elemento de la fila y realizar la suma correspondiente en la columna correspondiente.
columnas es el acumulador que almacena las sumas por columna.
En cada iteración, se utiliza map para sumar el elemento de la fila actual con el elemento correspondiente en columnas (o 0 si no existe).
Al finalizar, el resultado de reduce se asigna a la matriz tipos, que almacenará los sumatorios por columna.

En resumen, map se utiliza para iterar sobre cada fila de la matriz y aplicar una función a cada elemento, mientras que reduce se utiliza para realizar cálculos acumulativos en cada fila (para sumar elementos) o en toda la matriz (para acumular sumas por columna).

// Ejemplo de uso
const matriz1 = [  [1, 3, 1],
  [2, 1, 2],
  [3, 3, 3]
];
console.log(organizingContainers(matriz1)); // Imprime "Impossible"

const matriz2 = [  [0, 2, 1],
  [1, 1, 1],
  [2, 0, 0]
];
console.log(organizingContainers(matriz2)); // Imprime "Possible"

const matriz3 = [  [0, 2],
  [1, 1]
];
console.log(organizingContainers(matriz3)); // Imprime "Impossible"

DEV Community: jorgeabad

Retos JS. Calculando factoriales muy grandes con JS.

Factoriales muy grandes

Desafio.

Problemática de los números grandes en JavaScript. BigInt

¿Qué es BigInt?

Constructor de BigInt

Operaciones con BigInt

Errores típicos con BigInt

SOLUCIÓN.

Ejemplo de uso.

CLASE BUFFER EN NODE.JS

CLASE BUFFER EN NODE.JS

Creación, escritura y lectura de buffers.

Creación de buffer asignando tamaño.

Modificar y obtener el valor de un byte por su posición.

Leer y decodificar buffers

Creación de Buffer mediante el contenido a almacenar

Llenado de un buffer.

Comparar

Crear copias de un Buffer o copiar bytes entre Buffers.

Concatenar varios Buffer

Iterar un buffer.

Manipular buffers

Ejemplos empleando el módulo Buffer.

Listado de caracteres con puntos de código utf8.

Extraer información del flujo de datos de un archivo png.

Introducción a Buffer en JavaScript

Datos binarios.

Búfer. ArrayBuffer en JavaScript.

Codificación y juego de caracteres.

Codificación de caracteres. Estándares.

ASCII 7 bits

Codificaciones de 8 bits

ISO 10646, Unicode y UTF-8.

Reto JS. Organizando bolas en urnas con JS

Organizando bolas en urnas con JS

Desafío:

Ejemplo:

Solución:

Constructor de `BigInt`

Operaciones con `BigInt`

Errores típicos con `BigInt`