Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/BigInt below:

BigInt - JavaScript | MDN

Baseline Widely available

Los valores BigInt representan valores numéricos que son muy grandes para ser representados por el primitivo 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.

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.

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 también se puede tomar como un 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.

• 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 y operadores de igualdad: >, <, >=, <=, ==, !=, ===, !==
• Los operadores lógicos solo se basan en veracidad de los operandos.

Un par de operadores no admiten BigInt en absoluto:

• El unario más (+) 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 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); // 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:

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

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

• Es converido en un Boolean: mediante la función Boolean;
• cuando se usa con operadores lógicos ||, && y !; or
• dentro de una prueba condicional como una declaración 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

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.

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):

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:

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 }

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.

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:

• 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 analizándolas como si contuvieran un literal entero. Cualquier error en el análisis da como resultado un SyntaxError. La sintaxis es un subconjunto de cadenas numéricas literales, donde no se permiten puntos decimales ni indicadores de exponentes.
• Los Number lanzan un TypeError para evitar una coerción implícita no intencionada que provoque una pérdida de precisión.
• Los Symbol lanzan un TypeError.
• Los objetos primero se convierten en primitivos llamando a sus métodos [@@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 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.

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()

Crea un nuevo valor BigInt.

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.

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.

BigInt.prototype.toLocaleString()

Devuelve una cadena con una representación sensible al idioma de este valor BigInt. Anula el método 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().

// 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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4