BigInt en JavaScript: Números Enteros de Tamaño Arbitrario
Usa BigInt, el tipo primitivo introducido en ES2020 para trabajar con números enteros más allá del límite de Number. Entiende cuándo usarlo, sus operaciones y limitaciones.
TL;DR - Resumen rápido
- BigInt es un tipo primitivo introducido en ES2020 para números enteros de tamaño arbitrario
- Number solo puede representar enteros seguros hasta ±(2^53 - 1). BigInt no tiene ese límite
- Crea BigInt con sufijo 'n' (123n) o función BigInt(). No uses 'new'
- No puedes mezclar BigInt y Number en operaciones - debes convertir explícitamente
- BigInt solo soporta enteros - no hay decimales ni operaciones de punto flotante
- Comparación estricta (===) entre BigInt y Number es false, comparación suelta (==) puede ser true
- No funciona con Math, JSON.stringify() lo ignora, y typeof retorna 'bigint'
¿Qué es BigInt?
BigInt es el octavo tipo primitivo de JavaScript, introducido en ES2020 (2020). Su propósito es solucionar una limitación fundamental del tipo Number: el rango seguro de enteros. Number puede representar enteros de forma segura solo hasta ±(2^53 - 1), aproximadamente ±9 cuatrillones. Más allá de ese límite, pierdes precisión y los cálculos se vuelven incorrectos.
BigInt elimina completamente esta limitación. Puede representar números enteros de tamaño arbitrario - tan grandes como la memoria disponible lo permita. Esto lo hace esencial para aplicaciones que trabajan con identificadores muy grandes, criptografía, cálculos matemáticos de alta precisión, o timestamps en nanosegundos. La desventaja es que solo funciona con enteros - no hay soporte para decimales o punto flotante.
El Límite de Number
Number usa IEEE 754 de 64 bits, que dedica 53 bits a la mantisa. Por eso el entero seguro máximo es 2^53 - 1 = 9007199254740991 (disponible como Number.MAX_SAFE_INTEGER). Si intentas 9007199254740992 + 1, obtienes 9007199254740992 nuevamente en lugar de 9007199254740993 - pérdida de precisión. BigInt soluciona esto completamente.
Crear BigInt: Sintaxis y Formas
Hay dos formas principales de crear un BigInt: usando el sufijo 'n' después de un número literal, o usando la función BigInt(). El sufijo 'n' es la forma más común y directa. Importante: BigInt() es una función, no un constructor - no uses 'new' con ella.
El sufijo 'n' es la forma preferida para literales. La función BigInt() es útil cuando necesitas convertir valores dinámicos (strings, Numbers) a BigInt. Acepta números, strings numéricos, y otros BigInts. No acepta decimales - si le pasas 3.5, lanza un RangeError. typeof retorna "bigint", no "number", confirmando que es un tipo primitivo diferente.
Este ejemplo demuestra por qué BigInt es necesario. Number pierde precisión con enteros muy grandes - la suma incorrecta demuestra que 9007199254740992 + 1 = 9007199254740992 (sin cambio). BigInt maneja estos números correctamente sin pérdida de precisión. Puedes trabajar con números astronómicamente grandes que serían imposibles con Number.
Operaciones Matemáticas con BigInt
BigInt soporta las operaciones matemáticas básicas: suma (+), resta (-), multiplicación (*), división (/), módulo (%), y exponenciación (**). Sin embargo, hay diferencias importantes con Number: la división trunca hacia cero (descarta decimales), y no puedes mezclar BigInt con Number en la misma operación sin conversión explícita.
La operación más importante a notar es la división: con BigInt, 10n / 3n da 3n (no 3.333...), porque BigInt solo maneja enteros. Los decimales se descartan completamente. Los operadores de incremento (++), decremento (--), y operadores compuestos (+=, -=, etc.) funcionan normalmente. Los operadores bitwise también funcionan con BigInt, útil para operaciones de bits en números grandes.
División Entera
BigInt siempre realiza división entera, descartando la parte decimal. Esto puede causar sorpresas si esperas comportamiento de punto flotante. Por ejemplo, 5n / 2n es 2n (no 2.5). Si necesitas el residuo, usa el operador módulo: 5n % 2n da 1n. No hay forma de obtener decimales con BigInt - está diseñado solo para enteros.
Conversión entre Number y BigInt
BigInt y Number son tipos incompatibles - no puedes mezclarlos directamente en operaciones. Si intentas sumar un BigInt con un Number, obtienes un TypeError. Debes convertir explícitamente usando BigInt() para convertir a BigInt, o Number() para convertir a Number. Ten cuidado con la pérdida de precisión al convertir BigInt grande a Number.
Convertir Number a BigInt con BigInt() funciona bien dentro del rango seguro. Convertir BigInt a Number con Number() puede causar pérdida de precisión si el BigInt es mayor que Number.MAX_SAFE_INTEGER. JavaScript te advertirá en algunos casos, pero no siempre. La conversión desde strings es útil cuando recibes números grandes de APIs o inputs de usuario como strings.
Comparación y Igualdad con BigInt
La comparación entre BigInt y Number tiene reglas específicas. La comparación estricta (===) siempre es false porque son tipos diferentes. La comparación suelta (==) compara los valores numéricamente, ignorando el tipo. Los operadores relacionales (<, >, <=, >=) comparan valores numéricamente sin importar el tipo.
Este comportamiento es importante al trabajar con datos mixtos. Si comparas con ===, BigInt y Number nunca son iguales aunque representen el mismo valor. Con ==, se comparan numéricamente. Los operadores < y > siempre comparan numéricamente. En arrays, sort() funciona correctamente con BigInts. Boolean(0n) es false, todos los demás BigInts son truthy.
Truthy y Falsy con BigInt
BigInt sigue las reglas truthy/falsy: 0n es el único BigInt falsy, todos los demás son truthy. Esto incluye -1n (truthy, a diferencia de lo que algunos esperan). Esta consistencia con Number (donde solo 0 es falsy) hace que las condiciones se comporten predeciblemente.
Limitaciones y Restricciones de BigInt
BigInt tiene varias limitaciones importantes que debes conocer. No funciona con el objeto Math, no se serializa en JSON, no soporta operaciones unarias como +bigint (aunque -bigint funciona), y algunas APIs del navegador que esperan Number no aceptan BigInt sin conversión.
La limitación más molesta es JSON.stringify() - BigInt simplemente lanza un TypeError porque JSON no tiene especificación para enteros arbitrarios. Debes convertir a string manualmente antes de serializar. Math.sqrt(), Math.pow(), y todas las funciones Math no aceptan BigInt. El operador unario + (conversión rápida a número) no funciona con BigInt - esto es intencional para evitar conversiones accidentales y pérdida de precisión.
BigInt y JSON
La incompatibilidad con JSON es problemática en aplicaciones reales. Si necesitas serializar BigInt, tienes dos opciones: (1) Convertir a string antes de JSON.stringify() y parsear después, o (2) Usar un replacer/reviver personalizado con JSON.stringify/parse. Muchas APIs envían BigInt como strings por esta razón.
Casos de Uso Prácticos
Aunque BigInt puede parecer un tipo nicho, tiene casos de uso muy prácticos. Los más comunes son: trabajar con identificadores grandes de bases de datos (como Twitter/X IDs), timestamps de alta precisión (nanosegundos), criptografía, cálculos matemáticos exactos con enteros grandes, y procesamiento de datos científicos o financieros que requieren precisión absoluta.
El primer ejemplo muestra IDs de redes sociales - Twitter usa IDs de 64 bits que exceden Number.MAX_SAFE_INTEGER, causando problemas si los manejas como Number. El segundo ejemplo muestra cálculos exactos con BigInt - útil cuando necesitas precisión absoluta sin errores de punto flotante. Criptografía, números primos grandes, y factoriales masivos son otros casos donde BigInt es esencial.
Cuándo Usar BigInt
Usa BigInt cuando: (1) Trabajas con enteros mayores que Number.MAX_SAFE_INTEGER, (2) Necesitas precisión exacta en operaciones enteras sin errores de redondeo, (3) Manipulas IDs de bases de datos de 64 bits, (4) Implementas algoritmos criptográficos, (5) Calculas timestamps en nanosegundos. Para todo lo demás, Number es suficiente y más compatible.
Errores Comunes con BigInt
Los errores más comunes con BigInt vienen de olvidar que no se puede mezclar con Number, intentar usar decimales, olvidar el sufijo 'n', o asumir que funciona con APIs que esperan Number. También es fácil olvidar que JSON no soporta BigInt.
El primer error es mezclar tipos sin conversión - TypeError garantizado. El segundo es intentar decimales con BigInt - solo acepta enteros. El tercero es olvidar el sufijo 'n', creando un Number normal que puede perder precisión. El cuarto es usar 'new' cuando BigInt es una función, no un constructor. El quinto es intentar JSON.stringify() directamente. El sexto es usar Math con BigInt - no están diseñados para trabajar juntos.
Resumen: BigInt en JavaScript
Características de BigInt:
- •Tipo primitivo para enteros de tamaño arbitrario sin límites
- •Crear con sufijo 'n' (123n) o función BigInt(). No usar 'new'
- •Solo enteros - división trunca decimales. No punto flotante
- •No se puede mezclar con Number - conversión explícita necesaria
- •typeof retorna 'bigint'. No funciona con Math ni JSON.stringify()
Cuándo usar BigInt:
- •Enteros mayores que ±(2^53 - 1) / Number.MAX_SAFE_INTEGER
- •IDs de bases de datos de 64 bits (Twitter, Discord, etc.)
- •Timestamps de alta precisión en nanosegundos
- •Criptografía y cálculos matemáticos con enteros grandes
- •Cuando necesites precisión exacta sin errores de redondeo