HTML: Markup language
CSS: Styling language
JavaScript: Scripting language
Web APIs: Programming interfaces
All web technology
Learn web development
Discover our tools
Get to know MDN better
Esta página ha sido traducida del inglés por la comunidad. Aprende más y únete a la comunidad de MDN Web Docs.
View in English Always switch to English
This feature is well established and works across many devices and browser versions. It’s been available across browsers since septiembre de 2020.
Los valores BigInt representan valores numéricos que son muy grandes para ser representados por el primitivo number.
BigInt
number
Un valor BigInt, a veces también llamado solamente BigInt, es un primitivo bigint, creado al anexar una n al final de un literal entero o llamando a la función BigInt() (sin el operador new) y dándole un valor ded entero o un valor de cadena.
bigint
n
BigInt()
new
const previouslyMaxSafeInteger = 9007199254740991n; const alsoHuge = BigInt(9007199254740991); // 9007199254740991n const hugeString = BigInt("9007199254740991"); // 9007199254740991n const hugeHex = BigInt("0x1fffffffffffff"); // 9007199254740991n const hugeOctal = BigInt("0o377777777777777777"); // 9007199254740991n const hugeBin = BigInt( "0b11111111111111111111111111111111111111111111111111111", ); // 9007199254740991n
Los valores BigInt son similares a los valores Number de algunas maneras, per también difieren en algunos conceptos clave: Un valor BigInt no puede ser usado con métodos del objeto integrado Math y no puede ser mezclado con un valor numérico en operaciónes; tienen que ser convertidos al mismo tipo. Tenga cuidado al convertir valores de números a BigInt y viceversa varias veces ya que la precisión de un valor BigInt puede perderse cuando se lo fuerza ser un valor numérico.
Math
Cuando se compara con typeof, un valor BigInt (el primitivo bigint) dará "bigint":
typeof
"bigint"
typeof 1n === "bigint"; // true typeof BigInt("1") === "bigint"; // true
Un valor BigInt también se puede tomar como un Object:
Object
typeof Object(1n) === "object"; // true
La mayoría de los operadores soportan BigInts, sin embargo, la mayoría no permiten la mezcla de tipos entre operandos; ambos operandos deben ser BigInt o ninguno.
+
-
*
/
%
**
>>
<<
&
|
^
~
++
--
Los operadores que devuelven boleanos permiten mezclar números y BigInts como operandos:
>
<
>=
<=
==
!=
===
!==
Un par de operadores no admiten BigInt en absoluto:
>>>
Casos especiales:
const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n const maxPlusOne = previousMaxSafe + 1n; // 9007199254740992n const theFuture = previousMaxSafe + 2n; // 9007199254740993n, esto ahora funciona! const multi = previousMaxSafe * 2n; // 18014398509481982n const subtr = multi - 10n; // 18014398509481972n const mod = multi % 10n; // 2n const bigN = 2n ** 54n; // 18014398509481984n bigN * -1n; // -18014398509481984n const expected = 4n / 2n; // 2n const truncated = 5n / 2n; // 2n, not 2.5n
Un valor BigInt no es estrictamente igual a un valor numérico, pero lo es en términos generales:
0n === 0; // false 0n == 0; // true
Un valor numérico y un valor BigInt se pueden comparar como de costumbre:
1n < 2; // true 2n > 1; // true 2 > 2; // false 2n > 2; // false 2n >= 2; // true
Los valores BigInt y los valores numéricos se pueden mezclar en arrays y ser ordenados:
const mixed = [4n, 6, -12n, 10, 4, 0, 0n]; // [4n, 6, -12n, 10, 4, 0, 0n] mixed.sort(); // comportamiento de orden por defecto // [ -12n, 0, 0n, 10, 4n, 4, 6 ] mixed.sort((a, b) => a - b); // no funciona ya que la sustracción no funciona con tipos de datos mezclados // TypeError: can't convert BigInt value to Number value // orden con un comparador numérico apropiado mixed.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)); // [ -12n, 0, 0n, 4n, 4, 6, 10 ]
Tenga en cuenta que las comparaciones con valores BigInt envueltos como un Object actúan como con otros objetos, indicando solo igualdad cuando se compara la misma instancia de objeto:
Object(0n) === 0n; // false Object(0n) === Object(0n); // false const o = Object(0n); o === o; // true
Dado que la coerción entre valores numéricos y valores BigInt puede provocar una pérdida de precisión, se recomienda lo siguiente:
Un valor BigInt sigue las mismas reglas de conversión que Numbers cuando:
Boolean
||
&&
!
if
Es decir, solo 0n es falso; todo el resto es verdadero.
0n
if (0n) { console.log("¡Hola desde el if!"); } else { console.log("¡Hola desde el else!"); } // "¡Hola desde el else!" 0n || 12n; // 12n 0n && 12n; // 0n Boolean(0n); // false Boolean(12n); // true !12n; // false !0n; // true
Las operaciones admitidas en valores BigInt no son de tiempo constante y, por lo tanto, están abiertas a ataques de tiempo. Por lo tanto, los BigInt de JavaScript podría ser peligroso para su uso en criptografía sin factores atenuantes. Como ejemplo muy genérico, un atacante podría medir la diferencia de tiempo entre 101n ** 65537n y 17n ** 9999n y deducir la magnitud de los secretos, como las claves privadas en función del tiempo transcurrido. Si aún tiene que usar BigInts, consulte las preguntas frecuentes de ataques de sincronización para obtener consejos generales sobre el problema.
101n ** 65537n
17n ** 9999n
Usar JSON.stringify() con cualquier valor BigInt generará un TypeError, ya que los valores BigInt no se serializan en JSON por defecto. Sin embargo, JSON.stringify() deja una puerta trasera para valores de BigInt: intentaría llamar al método toJSON() de BigInt (no lo hace para ningún otro método primitivo). Por lo tanto, puede implementar su propio método toJSON() (que es uno de los pocos casos en los que no se desaconseja explícitamente aplicar parches a objetos integrados):
JSON.stringify()
TypeError
toJSON()
BigInt.prototype.toJSON = function () { return { $bigint: this.toString() }; };
En lugar de generar un error, JSON.stringify() ahora produce una cadena como esta:
console.log(JSON.stringify({ a: 1n })); // {"a":{"$bigint":"1"}}
Si no desea parchear BigInt.prototype, puede utilizar el parámetro replacer de JSON.stringify para serializar valores BigInt:
BigInt.prototype
replacer
JSON.stringify
const replacer = (key, value) => typeof value === "bigint" ? { $bigint: value.toString() } : value; const data = { number: 1, big: 18014398509481982n, }; const stringified = JSON.stringify(data, replacer); console.log(stringified); // {"number":1,"big":{"$bigint":"18014398509481982"}}
Puedes usar entonces el parametro reviver de JSON.parse para manejarlos:
reviver
JSON.parse
const reviver = (key, value) => value !== null && typeof value === "object" && "$bigint" in value && typeof value.$bigint === "string" ? BigInt(value.$bigint) : value; const payload = '{"number":1,"big":{"$bigint":"18014398509481982"}}'; const parsed = JSON.parse(payload, reviver); console.log(parsed); // { number: 1, big: 18014398509481982n }
Nota: Si bien es posible hacer el reemplazo de JSON.stringify() genérico y propiamente serializar los valores BigInt para todos los objetos, el reviver JSON.parse() tiene que ser específico para la forma de carga útil esperada, ya que la serialización tiene pérdidas: no es posible distinguir entre una cadena que representa un BigInt y una cadena normal.
JSON.parse()
Además, el ejemplo de arriba crea un objeto entero en el replacing y reviving, lo que probablemente tenga implicaciónes de rendimiento y almacenamiento para objetos más grandes que contienen muchos BigInts. Si conoces la forma de carga útil esperada, puede ser mejor simplemente serializarlas como strings y revivirlas basadas en el nombre de la key.
De hecho, JSON permite números literales que son arbitrariamente largos; simplemente no se pueden analizar con total precisión en JavaScript. Si se está comunicando con otro programa en un lenguaje que admite enteros más largos (como enteros de 64 bits) y desea transmitir BigInt como un número en el JSON en lugar de una cadena de texto en el JSON, consulte sobre la Serialización de números sin pérdida.
Muchas operaciones integradas que esperan que BigInts primero coaccionen sus argumentos a BigInts. La operación se puede resumir de la siguiente manera:
undefined
null
true
1n
false
SyntaxError
[@@toPrimitive]()
"number"
valueOf()
toString()
La mejor manera de lograr casi el mismo efecto en JavaScript es a través de la función BigInt(): BigInt(x) usa el mismo algoritmo para convertir x excepto que los Number no lanzan un TypeError pero son convertidos en BigInts si son enteros.
BigInt(x)
x
Tenga en cuenta que las operaciones integradas que esperan BigInts a menudo truncan el BigInt a un ancho fijo después de la coerción. Esto incluye BigInt.asIntN(), BigInt.asUintN() y los métodos BigInt64Array y BigUint64Array.
BigInt.asIntN()
BigInt.asUintN()
BigInt64Array
BigUint64Array
Crea un nuevo valor BigInt.
Sujeta un valor BigInt a un valor entero con signo y devuelve ese valor.
Sujeta un valor BigInt a un valor entero sin signo y devuelve ese valor.
Estas propiedades están definidas en BigInt.prototype y compartidas por todas las instancias de BigInt.
BigInt.prototype.constructor
La función constructora que creó el objeto de instancia. Por las instancias BigInt, el valor inicial es constructor BigInt.
BigInt.prototype[@@toStringTag]
El valor inicial de la propiedad @@toStringTag es la cadena "BigInt". Esta propiedad es usada en Object.prototype.toString(). Sin embargo, debido a que BigInt también tiene si propio método toString(), esta propiedad no es usada a menos que llame a Object.prototype.toString.call() con un BigInt como thisArg.
@@toStringTag
"BigInt"
Object.prototype.toString()
Object.prototype.toString.call()
thisArg
BigInt.prototype.toLocaleString()
Devuelve una cadena con una representación sensible al idioma de este valor BigInt. Anula el método Object.prototype.toLocaleString().
Object.prototype.toLocaleString()
BigInt.prototype.toString()
Devuelve una cadena que representa este valor BigInt en la base especificada. Anula el método Object.prototype.toString().
BigInt.prototype.valueOf()
Devuelve este valor BigInt. Anula el método Object.prototype.valueOf().
Object.prototype.valueOf()
// Retorna true si el BigInt pasado es un número primo function isPrime(p) { for (let i = 2n; i * i <= p; i++) { if (p % i === 0n) return false; } return true; } // Recive un BigInt como argumento, devuelve el número primo más cercano para arriba como un valor BigInt function nthPrime(nth) { let maybePrime = 2n; let prime = 0n; while (nth >= 0n) { if (isPrime(maybePrime)) { nth--; prime = maybePrime; } maybePrime++; } return prime; } nthPrime(20n); // 73n
Enable JavaScript to view this browser compatibility table.
Number
Number.MAX_SAFE_INTEGER