JavaScript BigInt

Introducción a JavaScript BigInt

BigInt es un tipo primitivo integrado de JavaScript que representa números enteros de tamaño arbitrario — enteros mucho mayores de lo que el tipo Number puede almacenar de forma segura. Esta guía explica por qué existe BigInt, cómo crearlo y operarlo, dónde destaca (finanzas, criptografía, cómputo a gran escala) y los errores más comunes a tener en cuenta.

Por qué existe BigInt

El tipo Number de JavaScript es un valor de punto flotante de 64 bits. Solo puede representar enteros de forma exacta hasta Number.MAX_SAFE_INTEGER, que es 2^53 - 1 (9007199254740991). Más allá de ese límite, la aritmética ordinaria pierde precisión silenciosamente:

javascript— editable

Cuando necesitas enteros exactos mayores que este valor — IDs de una base de datos, moneda en la unidad más pequeña, claves criptográficas, factoriales — BigInt es la solución.

Entendiendo BigInt en JavaScript

Un BigInt es un tipo primitivo distinto de Number. El operador typeof devuelve "bigint" y tiene sus propias reglas aritméticas.

Sintaxis y creación

Crea un BigInt añadiendo n al final de un literal entero, o llamando a la función BigInt() con un número o una cadena de texto.

javascript— editable

Usa la forma de string cuando el valor provenga de una entrada o supere lo que un literal numérico puede expresar de forma segura. Pasar un número no entero (como BigInt(1.5)) lanza un RangeError.

Operaciones básicas con BigInt

BigInt soporta los mismos operadores aritméticos que Number, pero ambos operandos deben ser BigInt. La división trunca hacia cero — no hay parte fraccionaria.

javascript— editable

Observa que first / second es 2n, no 2.5 — la división con BigInt descarta el resto en lugar de producir una fracción.

Comparar BigInt y Number

Aunque son tipos distintos, BigInt y Number pueden compararse con operadores relacionales y el operador de igualdad débil ==. Solo la igualdad estricta === distingue los tipos, ya que también comprueba el tipo.

javascript— editable

Consulta los operadores de comparación para saber en qué se diferencian == y === en general.

Limitaciones y coerción de tipos

Aunque potente, BigInt tiene limitaciones específicas en comparación con el tipo Number estándar:

Sin coerción implícita en aritmética: No puedes sumar, multiplicar, etc. un BigInt y un Number juntos — lanza un TypeError. Convierte primero uno de los operandos.
Funciones Math: Los métodos estándar de Math (p. ej., Math.sqrt(), Math.floor()) no aceptan argumentos BigInt y lanzarán una excepción.
Sin más unario: +10n lanza un error — usa Number(10n) en su lugar.
JSON: JSON.stringify no puede serializar un BigInt y lanza un TypeError; conviértelo a string primero.
Conversión explícita: Convierte entre tipos con Number(bigint) o BigInt(number). Al convertir a Number puede perderse precisión con valores muy grandes.

javascript— editable

Aplicaciones prácticas de BigInt

La capacidad de BigInt para manejar números grandes con precisión lo hace invaluable en cálculos financieros, criptografía y computación a gran escala.

Cálculos financieros

En aplicaciones financieras, BigInt ayuda a evitar los errores de redondeo asociados a los números de punto flotante.

javascript— editable

Este ejemplo ilustra el uso de BigInt para aritmética de alta precisión en contextos financieros, garantizando la exactitud en las transacciones.

Información

BigInt es una herramienta esencial en criptografía, ya que desempeña un papel crucial en la generación de números primos grandes. Estos números son fundamentales para los mecanismos de seguridad de los algoritmos de cifrado, asegurando que los datos estén protegidos de forma eficaz.

Computación de alto rendimiento

El siguiente ejemplo demuestra el uso de BigInt en la multiplicación de matrices para el procesamiento de datos a gran escala, garantizando precisión y eficiencia. Incluiremos una implementación completa de la función de multiplicación de matrices usando BigInt. Esto implica inicializar matrices, poblarlas con valores BigInt y luego realizar la multiplicación. Aquí tienes un ejemplo real paso a paso:

Paso 1: Inicializar la matriz

Primero, creamos una función para inicializar una matriz de dimensiones dadas con ceros de tipo BigInt.

function initializeMatrix(rows, cols) {
  let matrix = new Array(rows);
  for (let i = 0; i < rows; i++) {
    matrix[i] = new Array(cols).fill(0n);
  }
  return matrix;
}

Paso 2: Función de multiplicación de matrices

A continuación, definimos la función para realizar la multiplicación de matrices. Ambas matrices de entrada deben contener valores BigInt, y la matriz resultante también contendrá valores BigInt.

function multiplyMatrices(matrixA, matrixB) {
  if (matrixA[0].length !== matrixB.length) {
    throw new Error('Number of columns in Matrix A must equal number of rows in Matrix B');
  }

  let resultMatrix = initializeMatrix(matrixA.length, matrixB[0].length);

  for (let i = 0; i < matrixA.length; i++) {
    for (let j = 0; j < matrixB[0].length; j++) {
      let sum = 0n;
      for (let k = 0; k < matrixA[0].length; k++) {
        sum += matrixA[i][k] * matrixB[k][j];
      }
      resultMatrix[i][j] = sum;
    }
  }
  return resultMatrix;
}

Paso 3: Matrices de ejemplo y multiplicación

Finalmente, creamos algunas matrices de ejemplo y realizamos la multiplicación. Las matrices se rellenan con valores BigInt.

javascript— editable

// Function to initialize a matrix with zeros (BigInt format)
function initializeMatrix(rows, cols) {
  let matrix = new Array(rows);
  for (let i = 0; i < rows; i++) {
    matrix[i] = new Array(cols).fill(0n); // Fill with BigInt zero
  }
  return matrix;
}

// Function to multiply two matrices that contain BigInt values
function multiplyMatrices(matrixA, matrixB) {
  if (matrixA[0].length !== matrixB.length) {
    throw new Error('The number of columns in Matrix A must be equal to the number of rows in Matrix B.');
  }

let resultMatrix = initializeMatrix(matrixA.length, matrixB[0].length);

for (let i = 0; i < matrixA.length; i++) {
    for (let j = 0; j < matrixB[0].length; j++) {
      let sum = 0n; // Start sum at BigInt zero
      for (let k = 0; k < matrixA[0].length; k++) {
        sum += matrixA[i][k] * matrixB[k][j]; // Add product of corresponding elements
      }
      resultMatrix[i][j] = sum; // Assign sum to the current position in result matrix
    }
  }
  return resultMatrix;
}

// Example matrices filled with BigInt values
let matrixA = [
  [1n, 2n],
  [3n, 4n]
];

let matrixB = [
  [2n, 0n],
  [1n, 2n]
];

// Perform matrix multiplication
let result = multiplyMatrices(matrixA, matrixB);

// Output the matrices by converting BigInt values to strings
console.log('Matrix A:', matrixA.map(row => row.map(value => `${value}n`)));
console.log('Matrix B:', matrixB.map(row => row.map(value => `${value}n`)));
console.log('Result of Multiplication:', result.map(row => row.map(value => `${value}n`)));

Explicación de la salida

Este ejemplo multiplica dos matrices 2x2 rellenas con BigInts. La salida será una nueva matriz donde cada elemento es el resultado de las reglas de multiplicación de matrices aplicadas a valores BigInt. Así es como queda la multiplicación:

Result[0][0] = (1n * 2n) + (2n * 1n) = 2n + 2n = 4n
Result[0][1] = (1n * 0n) + (2n * 2n) = 0n + 4n = 4n
Result[1][0] = (3n * 2n) + (4n * 1n) = 6n + 4n = 10n
Result[1][1] = (3n * 0n) + (4n * 2n) = 0n + 8n = 8n

Esta funcionalidad demuestra cómo BigInt puede utilizarse para manejar números grandes en cálculos complejos como la multiplicación de matrices, garantizando precisión y rendimiento en aplicaciones JavaScript que requieren cómputos numéricos a gran escala.

Advertencia

Usa BigInt con prudencia, ya que puede afectar al rendimiento por sus mayores demandas de memoria y procesamiento en comparación con los números estándar. Úsalo solo cuando sea necesario para manejar enteros muy grandes.

Mejores prácticas para usar BigInt en JavaScript

Al incorporar BigInt en tus proyectos JavaScript, considera las siguientes mejores prácticas para optimizar el rendimiento y la mantenibilidad:

Tipos de datos consistentes: Evita mezclar BigInt con otros tipos numéricos. La coerción entre BigInt y Number puede provocar errores o comportamientos inesperados. Asegúrate de que todos los operandos en los cálculos sean de tipo BigInt cuando sea necesario.
Adecuación al caso de uso: Emplea BigInt solo cuando trabajes con números fuera del rango seguro para los números estándar de JavaScript. El uso excesivo de BigInt puede generar sobrecarga de rendimiento.
Consideraciones de memoria: Aunque BigInt puede manejar números muy grandes, ten en cuenta el uso de memoria en tus aplicaciones, especialmente en entornos con recursos limitados.
Verificación de compatibilidad: Antes de usar BigInt, comprueba la compatibilidad con el entorno JavaScript de destino, ya que los navegadores más antiguos o algunos motores JavaScript pueden no admitirlo.
Algoritmos eficientes: Al realizar operaciones con BigInt, especialmente en bucles o funciones recursivas, optimiza tus algoritmos para minimizar el impacto en el rendimiento.

Entendiendo los polyfills para BigInt en JavaScript

El tipo BigInt de JavaScript es esencial para manejar enteros muy grandes, pero no está soportado en todos los entornos. Para garantizar la compatibilidad entre diferentes navegadores y motores JavaScript, especialmente los más antiguos, el uso de polyfills para BigInt puede ser un enfoque práctico.

¿Qué es el polyfilling?

El polyfilling es una técnica utilizada para implementar funcionalidades en navegadores web que no las admiten de forma nativa. Consiste en incluir un script que agrega la funcionalidad faltante al entorno JavaScript del navegador, permitiendo a los desarrolladores usar características modernas sin esperar a que todos los usuarios cambien a navegadores que las soporten.

Aplicando polyfill a BigInt

Dado que BigInt es una adición relativamente reciente a JavaScript, no todos los entornos lo admiten. El polyfilling te permite usar BigInt en estos entornos no compatibles simulando su funcionalidad. Esto puede ser crucial para aplicaciones que requieren cálculos de alta precisión en entornos donde actualizar a la última versión del navegador no es viable.

Implementando un polyfill para BigInt

Implementar un polyfill para BigInt implica crear o incluir una biblioteca que imite el comportamiento de BigInt. Aquí hay una demostración conceptual simple de cómo podría estructurarse un polyfill:

// Conceptual demonstration only. A true BigInt polyfill is complex and impractical.
// This example uses Number conversion internally for simplicity and is not suitable 
// for production large-integer handling.
if (typeof BigInt === "undefined") {
    window.BigInt = function(value) {
        return {
            value: value,
            toString: function() { return value + "n"; },
            add: function(other) { return BigInt(Number(this.value) + Number(other.value)); },
            subtract: function(other) { return BigInt(Number(this.value) - Number(other.value)); }
        };
    };
}

Limitaciones del polyfilling para BigInt

Aunque los polyfills pueden proporcionar compatibilidad con versiones anteriores, no son un sustituto perfecto de las implementaciones nativas:

Rendimiento: Los polyfills no pueden igualar el rendimiento de las operaciones nativas de BigInt, ya que están implementados en JavaScript en lugar de en código de bajo nivel optimizado por los fabricantes de navegadores.
Complejidad: Imitar con precisión todos los aspectos de una funcionalidad compleja como BigInt puede ser difícil y podría dar lugar a errores o inconsistencias.
Mantenimiento: Mantener el polyfill actualizado con cualquier cambio en la especificación oficial de BigInt requiere mantenimiento continuo.

Información

Considera usar un polyfill de BigInt para habilitar la compatibilidad en navegadores más antiguos que no admiten BigInt de forma nativa. Sin embargo, ten en cuenta que los polyfills pueden no ofrecer el mismo rendimiento que las implementaciones nativas y deben usarse como solución temporal hasta que el soporte nativo esté más universalmente disponible.

Conclusión

BigInt permite a JavaScript representar enteros de cualquier tamaño con precisión exacta, llenando el vacío dejado por el límite seguro de 53 bits del tipo Number. Recurre a él siempre que un entero pueda superar Number.MAX_SAFE_INTEGER — IDs grandes de bases de datos, moneda en unidades menores, valores criptográficos y cálculos con números grandes — pero mantén Number para los cálculos cotidianos donde las fracciones y los métodos de Math son importantes. Recuerda la regla fundamental: nunca mezcles BigInt y Number en operaciones aritméticas sin una conversión explícita.

Temas relacionados

JavaScript Numbers — el tipo numérico estándar y su límite de enteros seguros.
JavaScript Math — funciones matemáticas (que trabajan con Number, no con BigInt).
JavaScript Data Types — dónde encaja bigint entre los primitivos.
Comparison Operators — comportamiento de == vs === utilizado anteriormente.

Práctica

¿Cuál es la forma correcta de crear un BigInt en JavaScript?

Añadiendo una 'n' al final del entero.Añadiendo una 'b' al final del entero.Usando la función Big().Usando la función BigInt().