BigInt

Descripcin

Un valor BigInt, a veces tambin llamado solamente BigInt, es un primitivo bigint, creado al anexar una n al final de un literal entero o llamando a la funcin BigInt() (sin el operador new) y dndole un valor ded entero o un valor de cadena.

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 tambin difieren en algunos conceptos clave: Un valor BigInt no puede ser usado con mtodos del objeto integrado Math y no puede ser mezclado con un valor numrico en operacines; tienen que ser convertidos al mismo tipo. Tenga cuidado al convertir valores de nmeros a BigInt y viceversa varias veces ya que la precisin de un valor BigInt puede perderse cuando se lo fuerza ser un valor numrico.

Informacin del tipo

Cuando se compara con typeof, un valor BigInt (el primitivo bigint) dar "bigint":

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

Un valor BigInt tambin se puede tomar como un Object:

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

Operadores

La mayora de los operadores soportan BigInts, sin embargo, la mayora no permiten la mezcla de tipos entre operandos; ambos operandos deben ser BigInt o ninguno.

• Operadores aritmticos: +, -, *, /, %, **
• Operadores bit a bit: >>, <<, &, |, ^, ~
• Negacin unaria (-)
• Incremento/decremento: ++, --

Los operadores que devuelven boleanos permiten mezclar nmeros y BigInts como operandos:

• Operadores relacionales y operadores de igualdad: >, <, >=, <=, ==, !=, ===, !==
• Los operadores lgicos solo se basan en veracidad de los operandos.

Un par de operadores no admiten BigInt en absoluto:

• El unario ms (+) no puede ser soportado por conflictos con el uso de asm.js, as que ha sido omitido para no causar errores en asm.js.
• El operador de desplazamiento a al derecha sin signo (>>>) es el nico operador bit a bit que no est soportado ya que todos los valores BigInt estn firmados.

Casos especiales:

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

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

Comparaciones

Un valor BigInt no es estrictamente igual a un valor numrico, pero lo es en trminos generales:

0n === 0; // false
0n == 0; // true

Un valor numrico 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 numricos 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 sustraccin no funciona con tipos de datos mezclados
// TypeError: can't convert BigInt value to Number value

// orden con un comparador numrico 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 actan 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 coercin entre valores numricos y valores BigInt puede provocar una prdida de precisin, se recomienda lo siguiente:

• Utilice nicamente un valor BigInt cuando sea razonable esperar valores superiores a 253.
• No fuerces entre valores BigInt y valores numricos.

Condicionales

Un valor BigInt sigue las mismas reglas de conversin que Numbers cuando:

• Es converido en un Boolean: mediante la funcin Boolean;
• cuando se usa con operadores lgicos ||, && y !; or
• dentro de una prueba condicional como una declaracin if.

Es decir, solo 0n es falso; todo el resto es verdadero.

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

Criptografa

Las operaciones admitidas en valores BigInt no son de tiempo constante y, por lo tanto, estn abiertas a ataques de tiempo. Por lo tanto, los BigInt de JavaScript podra ser peligroso para su uso en criptografa sin factores atenuantes. Como ejemplo muy genrico, un atacante podra medir la diferencia de tiempo entre 101n ** 65537n y 17n ** 9999n y deducir la magnitud de los secretos, como las claves privadas en funcin del tiempo transcurrido. Si an tiene que usar BigInts, consulte las preguntas frecuentes de ataques de sincronizacin para obtener consejos generales sobre el problema.

Uso dentro de JSON

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: intentara llamar al mtodo toJSON() de BigInt (no lo hace para ningn otro mtodo primitivo). Por lo tanto, puede implementar su propio mtodo toJSON() (que es uno de los pocos casos en los que no se desaconseja explcitamente 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 parchear BigInt.prototype, puede utilizar el parmetro replacer de JSON.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 parametro reviver de JSON.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 nmeros literales que son arbitrariamente largos; simplemente no se pueden analizar con total precisin en JavaScript. Si se est comunicando con otro programa en un lenguaje que admite enteros ms largos (como enteros de 64 bits) y desea transmitir BigInt como un nmero en el JSON en lugar de una cadena de texto en el JSON, consulte sobre la Serializacin de nmeros sin prdida.

Coercin BigInt

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

• Los BigInts se devuelven tal cual.
• undefined y null lanzan un TypeError.
• true se convierte en 1n; false se convierte en 0n.
• Las cadenas se convierten analizndolas como si contuvieran un literal entero. Cualquier error en el anlisis da como resultado un SyntaxError. La sintaxis es un subconjunto de cadenas numricas literales, donde no se permiten puntos decimales ni indicadores de exponentes.
• Los Number lanzan un TypeError para evitar una coercin implcita no intencionada que provoque una prdida de precisin.
• Los Symbol lanzan un TypeError.
• Los objetos primero se convierten en primitivos llamando a sus mtodos [@@toPrimitive]() (con "number" como una sugerencia), valueOf(), y toString(), en ese orden. La primitiva resultante se convierte luego en BigInt.

La mejor manera de lograr casi el mismo efecto en JavaScript es a travs de la funcin 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.

Tenga en cuenta que las operaciones integradas que esperan BigInts a menudo truncan el BigInt a un ancho fijo despus de la coercin. Esto incluye BigInt.asIntN(), BigInt.asUintN() y los mtodos BigInt64Array y BigUint64Array.

Constructor

BigInt()

Crea un nuevo valor BigInt.

Mtodos estticos

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 estn definidas en BigInt.prototype y compartidas por todas las instancias de BigInt.

BigInt.prototype.constructor

La funcin 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 tambin tiene si propio mtodo toString(), esta propiedad no es usada a menos que llame a Object.prototype.toString.call() con un BigInt como thisArg.

Mtodos de instancia

BigInt.prototype.toLocaleString()

Devuelve una cadena con una representacin sensible al idioma de este valor BigInt. Anula el mtodo Object.prototype.toLocaleString().

BigInt.prototype.toString()

Devuelve una cadena que representa este valor BigInt en la base especificada. Anula el mtodo Object.prototype.toString().

BigInt.prototype.valueOf()

Devuelve este valor BigInt. Anula el mtodo Object.prototype.valueOf().

Ejemplos

Calculando primos

// Retorna true si el BigInt pasado es un nmero 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 nmero primo ms 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

Especificaciones

Compatibilidad con navegadores

Vase tambin

• Number
• Number.MAX_SAFE_INTEGER