Los valoresBigInt representan valores numéricos que sonmuy grandes para ser representados por elprimitivonumber.

Descripción

Unvalor BigInt, a veces también llamado solamenteBigInt, es unprimitivobigint, creado al anexar unan al final de un literal entero o llamando a la funciónBigInt() (sin el operadornew) y dándole un valor ded entero o un valor de cadena.

const previouslyMaxSafeInteger = 9007199254740991n;const alsoHuge = BigInt(9007199254740991);// 9007199254740991nconst hugeString = BigInt("9007199254740991");// 9007199254740991nconst hugeHex = BigInt("0x1fffffffffffff");// 9007199254740991nconst hugeOctal = BigInt("0o377777777777777777");// 9007199254740991nconst 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 integradoMath 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.

Información del tipo

Cuando se compara contypeof, un valor BigInt (el primitivobigint) dará"bigint":

typeof 1n === "bigint"; // truetypeof BigInt("1") === "bigint"; // true

Un valor BigInt también se puede tomar como unObject:

typeof Object(1n) === "object"; // true

Operadores

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.

• Operadores aritméticos:+,-,*,/,%,**
• Operadores bit a bit:>>,<<,&,|,^,~
• Negación unaria (-)
• Incremento/decremento:++,--

Los operadores que devuelven boleanos permiten mezclar números y BigInts como operandos:

• Operadores relacionales yoperadores de igualdad:>,<,>=,<=,==,!=,===,!==
• Losoperadores lógicos solo se basan enveracidad de los operandos.

Un par de operadores no admiten BigInt en absoluto:

• Elunario más (+) no puede ser soportado por conflictos con el uso de asm.js, así que ha sido omitidopara no causar errores en asm.js.
• El operador dedesplazamiento a al derecha sin signo (>>>) es el único operador bit a bit que no está soportado ya que todos los valores BigInt están firmados.

Casos especiales:

• La suma (+) que involucra una cadena y un BigInt devuelve una cadena.
• La división (/) trunca los componentes fraccionarios hacia cero, ya que BigInt no puede representar cantidades fraccionarias.

const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991nconst maxPlusOne = previousMaxSafe + 1n; // 9007199254740992nconst theFuture = previousMaxSafe + 2n; // 9007199254740993n, esto ahora funciona!const multi = previousMaxSafe * 2n; // 18014398509481982nconst subtr = multi - 10n; // 18014398509481972nconst mod = multi % 10n; // 2nconst bigN = 2n ** 54n; // 18014398509481984nbigN * -1n; // -18014398509481984nconst expected = 4n / 2n; // 2nconst truncated = 5n / 2n; // 2n, not 2.5n

Comparaciones

Un valor BigInt no es estrictamente igual a un valor numérico, pero lo es en términos generales:

0n === 0; // false0n == 0; // true

Un valor numérico y un valor BigInt se pueden comparar como de costumbre:

1n < 2; // true2n > 1; // true2 > 2; // false2n > 2; // false2n >= 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 apropiadomixed.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 unObject actúan como con otros objetos, indicando solo igualdad cuando se compara la misma instancia de objeto:

Object(0n) === 0n; // falseObject(0n) === Object(0n); // falseconst 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:

• Utilice únicamente un valor BigInt cuando sea razonable esperar valores superiores a 2⁵³.
• No fuerces entre valores BigInt y valores numéricos.

Condicionales

Un valor BigInt sigue las mismas reglas de conversión que Numbers cuando:

• Es converido en unBoolean: mediante la funciónBoolean;
• cuando se usa conoperadores lógicos||,&& y!; or
• dentro de una prueba condicional como una declaraciónif.

Es decir, solo0n esfalso; todo el resto esverdadero.

if (0n) {  console.log("¡Hola desde el if!");} else {  console.log("¡Hola desde el else!");}// "¡Hola desde el else!"0n || 12n; // 12n0n && 12n; // 0nBoolean(0n); // falseBoolean(12n); // true!12n; // false!0n; // true

Criptografía

Las operaciones admitidas en valores BigInt no son de tiempo constante y, por lo tanto, están abiertas aataques 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 entre101n ** 65537n y17n ** 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 laspreguntas frecuentes de ataques de sincronización para obtener consejos generales sobre el problema.

Uso dentro de JSON

UsarJSON.stringify() con cualquier valor BigInt generará unTypeError, 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étodotoJSON() de BigInt (no lo hace para ningún otro método primitivo). Por lo tanto, puede implementar su propio métodotoJSON() (que es uno de los pocos casos en los que no se desaconseja explícitamente aplicar parches a objetos integrados):

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 parchearBigInt.prototype, puede utilizar el parámetroreplacer deJSON.stringify para serializar valores BigInt:

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 parametroreviver deJSON.parse para manejarlos:

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 }

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 laSerialización de números sin pérdida.

Coerción BigInt

Muchas operaciones integradas que esperan que BigInts primero coaccionen sus argumentos a BigInts.La operación se puede resumir de la siguiente manera:

• Los BigInts se devuelven tal cual.
• undefined ynull lanzan unTypeError.
• true se convierte en1n;false se convierte en0n.
• Las cadenas se convierten analizándolas como si contuvieran un literal entero. Cualquier error en el análisis da como resultado unSyntaxError. La sintaxis es un subconjunto decadenas numéricas literales, donde no se permiten puntos decimales ni indicadores de exponentes.
• LosNumber lanzan unTypeError para evitar una coerción implícita no intencionada que provoque una pérdida de precisión.
• LosSymbol lanzan unTypeError.
• Los objetos primerose convierten en primitivos llamando a sus métodos[@@toPrimitive]() (con"number" como una sugerencia),valueOf(), ytoString(), en ese orden. La primitiva resultante se convierte luego en BigInt.

La mejor manera de lograr casi el mismo efecto en JavaScript es a través de la funciónBigInt():BigInt(x) usa el mismo algoritmo para convertirx excepto que losNumber no lanzan unTypeError pero son convertidos en BigInts si son enteros.

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 incluyeBigInt.asIntN(),BigInt.asUintN() y los métodosBigInt64Array yBigUint64Array.

Constructor

BigInt()

Crea un nuevo valor BigInt.

Métodos estáticos

BigInt.asIntN()

Sujeta un valor BigInt a un valor entero con signo y devuelve ese valor.

BigInt.asUintN()

Sujeta un valor BigInt a un valor entero sin signo y devuelve ese valor.

Propiedades de instancia

Estas propiedades están definidas enBigInt.prototype y compartidas por todas las instancias deBigInt.

BigInt.prototype.constructor

La función constructora que creó el objeto de instancia. Por las instanciasBigInt, el valor inicial es constructorBigInt.

BigInt.prototype[@@toStringTag]

El valor inicial de la propiedad@@toStringTag es la cadena"BigInt". Esta propiedad es usada enObject.prototype.toString(). Sin embargo, debido a queBigInt también tiene si propio métodotoString(), esta propiedad no es usada a menos que llame aObject.prototype.toString.call() con un BigInt comothisArg.

Métodos de instancia

BigInt.prototype.toLocaleString()

Devuelve una cadena con una representación sensible al idioma de este valor BigInt. Anula el métodoObject.prototype.toLocaleString().

BigInt.prototype.toString()

Devuelve una cadena que representa este valor BigInt en la base especificada. Anula el métodoObject.prototype.toString().

BigInt.prototype.valueOf()

Devuelve este valor BigInt. Anula el métodoObject.prototype.valueOf().

Ejemplos

Calculando primos

// Retorna true si el BigInt pasado es un número primofunction 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 BigIntfunction nthPrime(nth) {  let maybePrime = 2n;  let prime = 0n;  while (nth >= 0n) {    if (isPrime(maybePrime)) {      nth--;      prime = maybePrime;    }    maybePrime++;  }  return prime;}nthPrime(20n);// 73n

Especificaciones

Compatibilidad con navegadores

Véase también

• Number
• Number.MAX_SAFE_INTEGER