Guía de uso de JavaScript BigInt

Guía de uso de JavaScript BigInt

Todos sabemos que JavaScript es un lenguaje en constante evolución. Antes del lanzamiento de la versión 2020 de ES2020, no existía una forma nativa de representar y realizar operaciones matemáticas con precisión en números mayores 9,007,199,254,740,991o 2**53 – 1menores que -9,007,199,254,740,991o . -(2**53 – 1)La mayoría de los desarrolladores confían en bibliotecas como JSBI y bignumber.js para realizar cálculos con números muy grandes.

Esta situación da lugar a otro tipo de datos llamado BigInt. BigIntLa introducción de JavaScript eleva a ocho el número total de tipos de datos de JavaScript. En este artículo aprenderemos BigIntqué es, sus ventajas y cómo utilizarlo correctamente en JavaScript. Para obtener más información sobre cómo representar números grandes en aplicaciones Node.js, consulte Cómo manejar números grandes en aplicaciones Node.js.

¿Qué es BigInt?

BigIntes un tipo de datos numéricos que se puede utilizar para representar números pequeños y grandes que no se pueden representar con tipos de datos numéricos más antiguos number. Cada BigIntvalor debe contener una letra minúscula después del número n, 897np.e. Por lo tanto, es exacto decir que 21no es estrictamente igual a 21n, ya que el primero es uno numbery el segundo es uno bigint.

Cuando realizas cálculos con cualquier número mayor que 9,007,199,254,740,991o , en realidad no obtienes una respuesta exacta. Number.MAX_SAFE_INTEGERPodemos ver un ejemplo a continuación:

const largeNumber = Number.MAX_SAFE_INTEGER; // or 9007199254740991

const addOne = largeNumber + 1;
console.log(addOne);
// returns 9007199254740992

const addTwo = largeNumber + 2;
console.log(addTwo);
// Also returns 9007199254740992
// Should return 9007199254740993

const addSix = largeNumber + 6;
console.log(addSix);
// returns 9007199254740996
// Should return 9007199254740997

const bb = 12n;

console.log(bb);

Sin embargo, podemos utilizar BigIntpara manejar este tipo de operaciones con precisión. Para definir un número entero como BigInt, podemos hacer cualquiera de las siguientes cosas: Podemos agregar al número entero o llamar al constructor nen todo el valor numérico o en una cadena que contenga solo el valor entero . BigInt()Por ejemplo el siguiente ejemplo:

// Method 1
const sampleBigIntOne = 234n;

// Method 2
const sampleBigIntTwo = BigInt(567)
// returns 567n

const sampleBigIntThree = BigInt("123")
// returns 123n

const sampleBigIntFour = 12356789900099999999912111n
// 仍然正确

Para verificar que un valor es BigIntde tipo podemos usar typeofel operador así:

const sampleOne = 17n
console.log(typeof sampleOne)
// Expected result: "bigint" 

const sampleTwo = BigInt(789);
console.log(typeof sampleTwo)
// Expected result: "bigint"
// 这是一个不推荐的写法

const sampleThree = typeof 17n === "bigint"
console.log(sampleThree)
// Expected result: true

Nota : BigIntNo se recomienda pasar números en constructores. En su lugar, es mejor simplemente agregarlo no envolverlo primero en una cadena, como en sampleBigIntOney respectivamente sampleBigIntThree.

Ejemplos de uso de BigInt

BigIntLos valores se utilizan en áreas de la vida o de la informática donde los grandes números son de suma importancia. A continuación se muestran BigIntalgunos casos de uso clave para:

• Cálculos financieros: BigIntimportante en los cálculos financieros, ya que se pueden manejar grandes volúmenes de transacciones y conversiones de moneda.
• Criptografía e informática segura: BigIntse utiliza en criptografía para generar números aleatorios muy grandes que son muy difíciles de predecir o descifrar.
• Desarrollo de juegos: en el desarrollo de juegos, a menudo se utilizan números grandes para guardar marcas de tiempo, puntuaciones y realizar un seguimiento del progreso. BigIntEl uso de garantiza una representación precisa de dichos valores.
• Sistemas distribuidos: los sistemas distribuidos requieren identidades únicas para funcionar con precisión. Dado que BigIntlos valores son infinitos, se pueden utilizar para generar identificadores y claves.

BigIntEs realmente importante en estas áreas porque permite a los desarrolladores manejar números enteros, marcas de tiempo, ID y procesos enormes de forma segura y precisa.

BigInt frente a número

En general, los números en JavaScript se pueden usar para representar números enteros o incluso números de punto flotante, como 69y 4.125677. Incluye valores entre 9,007,199,254,740,991o 2**53 – 1y -9,007,199,254,740,991o . Estos límites están disponibles como constantes, como y -(2**53 – 1)respectivamente .Number.MAX_SAFE_INTEGERNumber.MIN_SAFE_INTEGER

En realidad puedes hacer todas las operaciones aritméticas con números como suma ( +), resta ( -), multiplicación ( *), división ( /), resto o módulo ( %) y exponente ( **) sin ningún problema en este rango, pero BigIntno del todo.

BigIntSe puede utilizar para representar y realizar operaciones con números enteros de cualquier tamaño, excepto números de punto flotante o decimales, incluidos números mayores 9,007,199,254,740,991o menores que . -9,007,199,254,740,991Estos 17.2nvalores decimales no son válidos.

En general, todas las operaciones aritméticas excepto ( ) dan la respuesta matemática correcta BigIntcuando se usan entre dos o más valores. El operador de división no siempre dará un resultado exacto, por lo que operaciones como redondearán la parte decimal a en lugar de ./5n/2n2n2.5n

Restricciones de tipo de número

Los tipos numéricos de JavaScript se escriben como valores binarios IEEE 754 de 64 bits de doble precisión, con 52 bits utilizados para el significado y 1 y 11 bits utilizados para el signo y el exponente. Por lo tanto, siempre que lo utilicemos Number, podemos encontrarnos con algunas limitaciones. Estas restricciones incluyen:

• Error de redondeo y precisión numérica limitada
• No se puede realizar aritmética exacta fuera de los enteros seguros mínimos y máximos
• No se pueden realizar operaciones fuera del alcance MAX_VALUEyMIN_VALUE

JavaScript necesariamente redondea los números porque utiliza 64 bits para representar números de punto flotante. Esto significa que cada número en JavaScript se convierte en un número de punto flotante binario de doble precisión antes de almacenarse en la memoria. La representación de 64 bits de un número en realidad se divide en tres partes, incluidos los dígitos significativos , el exponente de desplazamiento y el signo .

Por ejemplo, un número como 15 se vería así cuando se convierta: 0.10000000010.1110000000000000000000000000000000000000000000000000.

La primera parte de un número binario de punto flotante de doble precisión es el signo, que puede ser 0 o 1, y representa el signo del número. Por tanto, un signo de 0 es positivo y viceversa. Ocupa 1 puesto. La segunda parte es el exponente de desplazamiento, que ocupa 11 bits, y la última parte es el dígito significativo o mantisa, que ocupa 52 bits.

Algunos números dan valores exactos, como 1/2, 1/4, 1/5, y o a o . Algunos otros números no dan valores exactos; en cambio, son decimales periódicos, como , , , .1/81/109,007,199,254,740,9912**53 – 1-9,007,199,254,740,991-(2**53 – 1)1/31/61/71/9

El problema es que algunos de estos números decimales pierden precisión cuando se convierten a binarios y viceversa. Entonces, cuando tomas un decimal (por ejemplo 0.1) y lo sumas 0.2, no suman 0.3. En cambio, suman 0.30000000000000004. Más ejemplos se encuentran a continuación:

const sample1 = 0.2 + 0.6;
console.log(sample1); //  0.6000000000000001

const sample2 = 0.3 + 0.6;
console.log(sample2);  // 0.8999999999999999

Este es un gran problema cuando se trabaja con números porque introduce mucho riesgo en los cálculos que requieren alta precisión. Este problema se evita cuando utilizamos BigInt, ya que no acepta decimales.

Los números de JavaScript solo son precisos si realiza operaciones aritméticas entre 9,007,199,254,740,991o 2**53 – 1hacia -9,007,199,254,740,991o . -(2**53 – 1)Entonces, cualquier cosa que haga fuera de ese rango puede generar respuestas incorrectas, por ejemplo:

const sample3 =  9_007_199_254_740_991 + 1; //  9,007,199,254,740,992

const sample4 = 9_007_199_254_740_991 + 2; // 9,007,199,254,740,992

console.log(sample3 === sample4); // true

JavaScript también tiene limitaciones en cuanto al tamaño de los números que puede representar. Se pueden representar mediante dos constantes incorporadas: Number.MAX_VALUEy Number.MIN_VALUE. Son esencialmente números: 1.7976931348623157e+308y, respectivamente 5e-324.

Cada vez que intentas Number.MAX_VALUErealizar una suma o resta usando , devuelve 1.7976931348623157e+308. Cuando intentas Number.MIN_VALUEhacer lo mismo con , devuelve el valor en el siguiente ejemplo:

const sample5 = Number.MAX_VALUE + 7;
console.log(sample5); // 1.7976931348623157e+308

const sample6 = Number.MAX_VALUE - 23;
console.log(sample6); // 1.7976931348623157e+308

const sample7 = Number.MIN_VALUE + 5;
console.log(sample7); // 5

const sample8 = Number.MIN_VALUE - 54;
console.log(sample8); // -54

Cuando Number.MAX_VALUErealizas la multiplicación ( *) o la exponenciación ( **), siempre devuelve infinito. Este valor se expresa como Number.POSITIVE_INFINITY.

Sólo se aplica la división Number.MAX_VALUE, sólo se aplica la multiplicación Number.MIN_VALUE. Esta es una limitación importante cuando es necesario realizar cálculos que involucran números muy grandes. Sin embargo, BigIntcon la ayuda de , podemos realizar cálculos con números muy grandes o muy pequeños.

Ventajas de usar BigInt

Ahora, profundicemos en las ventajas de usar JavaScript BigInt. Primero, BigIntasegúrese de que no encontremos errores de precisión. Cuando trabajamos con números, podemos trabajar con decimales, lo que puede dar lugar a errores de precisión y redondeo, como vimos en el apartado anterior.

Sin embargo, cuando usamos BigInt, no se nos permite usar decimales. Esto garantiza que estos errores siempre se eviten. Por lo tanto, no es válido hacer lo siguiente:

const sample1 = 5.4n;
// Uncaught SyntaxError: Invalid or unexpected token

BigIntTambién se pueden realizar cálculos de precisión arbitraria. A diferencia de los números, que pierden precisión al realizar cálculos fuera del rango de Number.MAX_SAFE_INTEGERy , nos permite realizar dichos cálculos sin perder precisión. Como se muestra en el siguiente ejemplo:Number.MIN_SAFE_INTEGERBigInt

const sample2 = BigInt(Number.MAX_SAFE_INTEGER) + 1n
const sample3 = BigInt(Number.MAX_SAFE_INTEGER) + 2n

console.log(sample2);  // 9007199254740992n

console.log(sample3); // 9007199254740993n

console.log(sample3 > sample2); // true  

Y usando BigInt, podemos Number.MAX_VALUErealizar cálculos de forma segura y precisa en números enteros mayores que , y debido a que tiene precisión arbitraria, el tamaño de los números enteros en los que puede realizar operaciones solo está limitado por la memoria disponible en la computadora o sistema host. No encontramos BigIntel mismo problema cuando usamos:

const max = BigInt(Number.MAX_VALUE);
console.log(max);
// 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368n

const sample4 = max + 7;
// 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858375n

const sample5 = max - 23;
// 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858345n

Además, BigIntnos permite poner límites (establecer límites) al número de dígitos que se calcularán para que podamos definir rangos de enteros apropiados para nuestro programa. Podemos lograr esto usando los métodos y BigIntproporcionados en el prototipo .asIntNasUintN

Esencialmente, estos dos métodos se utilizan para encapsular BigIntvalores en enteros binarios con y sin signo de ancho fijo, respectivamente. Los números enteros con signo se utilizan para representar valores negativos y viceversa.

Entonces, si queremos limitar un cálculo a aritmética de 8, 16, 32 o 64 bits, podemos usar asIntNel método BigInt.asIntN(width, value)para hacerlo llamándolo. En este caso, widthel argumento representa los bits requeridos mayores que cero y valueel argumento representa el valor que queremos limitar dentro del widthvalor proporcionado BigInt.

Veamos un ejemplo:

const maximumBits = 16;

const valueOne = BigInt(32767);
const constrainedValueOne = BigInt.asIntN(maximumBits, valueOne);
console.log(constrainedValueOne); //  32767n

const valueTwo = BigInt(32768);
const constrainedValueTwo = BigInt.asIntN(maximumBits, valueTwo);
console.log(constrainedValueTwo); // -32768n

Como puede ver en el ejemplo anterior, creamos asIntNel límite de enteros de 16 bits para usar usando . En términos generales, 16 bits solo pueden contener números enteros entre -32768n. 32767nEntonces, en el primer ejemplo, devuelve el valor tal como está, mientras que en el último, trunca el valor porque está fuera del rango que especificamos.

BigIntTambién mejora la velocidad de las aplicaciones JavaScript. Antes de ES2020, los desarrolladores dependían de bibliotecas como Math.js y JSBI para calcular números grandes. Sin embargo, algunos de estos paquetes son grandes y lentos. Esto hace que las aplicaciones y el software creados con JavaScript funcionen más lentamente; sin embargo, BigIntla llegada de JavaScript puede mejorar las aplicaciones que realizan cálculos pesados.

Cómo utilizar BigInt en JavaScript

Como BigIntes un tipo de datos, Numbertambién se puede utilizar para realizar cálculos, similares a . Para definir BigIntun valor, podemos usar BigIntel identificador (es decir, n) o usar BigIntel constructor para una cadena que contenga números enteros o números.

Sin embargo, debemos tener cuidado al utilizar el constructor para convertir un número a BigInt, ya que el número puede perder precisión incluso antes de que se produzca la conversión. Por ejemplo:

const dontDoThis = BigInt(12345567891234567890)
console.log(dontDoThis); // 12345567891234568192n

const dontDoThisToo = BigInt(`${
      
      12345567891234567890}`)
console.log(dontDoThis); // 12345567891234568000n

Cómo utilizar BigInt

Puedes llamar BigInta cinco métodos diferentes de la clase:

• BigInt.prototype.toString()
• BigInt.prototype.valueOf()
• BigInt.prototype.toLocaleString()
• BigInt.asIntN()
• BigInt.asUintN()

Siempre que encuentre BigInt.prototype.toString()un método como, significa que toString()el método se llamará en BigIntla instancia del objeto (como 5n.toString()), mientras que un BigInt.asUintN()método como se BigIntllamará directamente en el constructor BigInt.asIntN(maximumBits, valueTwo).

BigInt.prototipo.toString()

Primero, echemos un vistazo BigInt.prototype.toString(). toString()Se utiliza para BigIntconvertir un valor en una cadena. Básicamente, lo envuelve entre comillas dobles o simples BigInty elimina las finales n. Se puede utilizar así:

const value1 = 35n;
const sample1 = value1.toString();

console.log(sample1); // "35"

Puede typeofverificar que el valor de retorno ahora es una cadena usando

const value1 = 35n;
const sample1 = value1.toString();
const valueDataType = typeof sample1;

console.log(valueDataType); // "string"

Alternativamente, también puedes BigIntpasar la base al convertir a una cadena. La base es en realidad la base a la que desea convertir. La base a pasar oscila entre 2 y 36. Además, cuando no se pasa ninguna base, el valor predeterminado es la base 10. Por tanto, puedes pasar la base así:

const value = 10n;

const newValueBase16 = value.toString(16);
console.log(newValueBase16); // "a"

const newValueBase5 = value.toString(5);
console.log(newValueBase5); // "20"

const newValueBase10 = value.toString(10);
console.log(newValueBase10);// "10"

BigInt.prototipo.valorDe()

valueOfMétodo utilizado para obtener BigIntel tipo original del objeto. Mira el siguiente ejemplo:

const value = Object(7n);

const valueOfDataType1 = typeof Object(7n);
console.log(valueOfDataType1); // "object"

// 你可以使用 .valueOf 方法来获取原始类型
const valueOfDataType2 = typeof Object(7n).valueOf();
console.log(valueOfDataType2); // "bigint"

BigInt.prototype.toLocaleString()

toLocaleString()El método es toString()similar a , sin embargo, se puede utilizar para devolver una cadena en una forma o formato específico del idioma. Acepta dos parámetros, a saber localey options. Se puede utilizar así:

const value = 23345689n;

const valueAsFormattedString = value.toLocaleString('en-US');
console.log(valueAsFormattedString); // 23,345,689

const valueAsFormattedStringWithOptions = value.toLocaleString('en-US', {
    
     style: 'currency', currency: 'USD' })
console.log(valueAsFormattedStringWithOptions); // $23,345,689.00

BigInt.asIntN()

BigInt.asIntN()Se utiliza para BigIntlimitar un valor a un ancho de bits establecido conservando al mismo tiempo el signo del valor. Sintaxis: BigInt.asIntN(bitWidth, BigIntValue). BigIntPor tanto, es adecuado cuando queremos conservar el signo de un valor (incluso si queremos restringirlo).

En términos generales bitWidthpuede ser de 8 bits, 16 bits, 32 bits, etc. Entonces, cuando configuramos el ancho en 8 bits, básicamente estamos diciendo que aceptamos un total de 256 valores BigInt que van desde -128hasta 128. Si el valor cae dentro del rango de valores mantenido por el bit, el valor se devuelve sin cambios; si cae fuera del rango, se devuelve el valor equivalente al valor en el bit. Por ejemplo:

const bits = 8;
const value1 = 126n; // 在范围为 -128 到 128 之间
const value2 = 127n; // 在范围为 -128 到 128 之间
const value3 = 128n; // 不在范围为 -128 到 128 之间
const value4 = 129n; // 不在范围为 -128 到 128 之间
const value5 = -67n; // 在范围为 -128 到 128 之间

const result1 = BigInt.asIntN(bits, value1);
console.log(result1); //126n

const result2 = BigInt.asIntN(bits, value2);
console.log(result2); // 127n

const result3 = BigInt.asIntN(bits, value3);
console.log(result3); //  -128n

const result4 = BigInt.asIntN(bits, value4);
console.log(result4); // -127n

const result5 = BigInt.asIntN(bits, value5);
console.log(result5); // -67n

BigInt.asUintN()

BigInt.asUintN()Similar a BigInt.asIntN(). BigIntLa principal diferencia es que ignora el signo del valor a restringir , que solo está restringido entre cero y el número máximo de bits que se pueden contener. Por ejemplo, 8 bits pueden contener 256 valores; por lo tanto, está limitado de 0 a 256, inclusive. Por ejemplo:

const bits = 8;
const value1 = 254n; // 在 0 到 256 之间
const value2 = 255n; // 在 0 到 256 之间
const value3 = 256n; // 不在 0 到 256 之间
const value4 = 257n; // 不在 0 到 256 之间
const value5 = 258n; // 不在 0 到 256 之间

const result1 = BigInt.asUintN(bits, value1);
console.log(result1); // 254n

const result2 = BigInt.asUintN(bits, value2);
console.log(result2); // 255n

const result3 = BigInt.asUintN(bits, value3);
console.log(result3); // 0n

const result4 = BigInt.asUintN(bits, value4);
console.log(result4); // 1n

const result5 = BigInt.asUintN(bits, value5);
console.log(result5); // 2n

Declaración condicional BigInt

Las condiciones que se aplican a Numbertambién se aplican a BigInt. Esto significa que ||, &&y !también puede BigIntfuncionar normalmente con . Además, cuando usamos ifla declaración, solo el valor 0nse evalúa como false, mientras que los demás valores son true:

if(0n){
    
    
  console.log('It is in if')
}else{
    
    
  console.log("it is in else")
}
// "it is in else"

if(-2n){
    
    
  console.log("it is in if")
}else{
    
    
  console.log("it is in else")
}
// "it is in if"

if(67n){
    
    
   console.log("it is in if")
}else{
    
    
  console.log("it is in else")
}
// "it is in if"

Incluso Booleanla función funciona como se esperaba, solo 0nse evaluará falsecomo así:

const isValueNone = Boolean(0n);
console.log(isValueNone); // false

const isValueExists1 = Boolean(79n);
console.log(isValueExists1);  // true

const isValueExists2 = Boolean(-65n);
console.log(isValueExists2); // true

Reglas y precauciones comunes de BigInt

Para poder utilizarlo BigIntsin errores debemos seguir algunas reglas:

• BigIntNo utilice newla palabra clave al crear
• No Bigintuses decimales en
• BigInterror de conversión
• No utilizar directamente JSON.stringifyconBigInt
• Métodos integrados limitados
• BigIntLa operación de división devuelve un resultado truncado

En primer lugar, BigIntno utilice newla palabra clave al crear. En JavaScript, solemos usar newla palabra clave para inicializar instancias de una clase. Sin embargo, BigInteste no es el caso porque cuando usamos newla palabra clave, arroja TypeError:

const value = new BigInt(54);
// TypeError: BigInt is not a constructor

Además, no Bigintutilice decimales en . BigIntSe produce cuando intentamos convertir decimal a valor RangeError. De manera similar, cuando utilizamos una conversión implícita con un punto decimal BigInt, obtenemos SyntaxError:

const value = 7.8n + 9n;
// SyntaxError: Invalid or unexpected token

Además, puede encontrar BigInterrores de conversión, por ejemplo, al mezclar Numbercon BigIntwill throw TypeError:

const result = 2n + 4;
console.log(result);
// TypeError: Cannot mix BigInt and other types, use explicit conversions

Además, nullusar undefinedy Symbolwith BigIntarrojará un error:

console.log(BigInt(null));
// TypeError: can't convert null to BigInt

console.log(BigInt(undefined));
// TypeError: can't convert undefined to BigInt

console.log(BigInt(Symbol()));
// TypeError: can't convert Symbol() to BigInt

Para evitar más errores, no lo utilice directamente JSON.stringifycon BigInt. No podemos BigIntusarlo directamente en JSON.stringifywill throw TypeError:

const theStringified = JSON.stringify(5n);
console.log(theStringified);
// TypeError: BigInt value can't be serialized in JSON

En su lugar, podemos BigIntcadenar el valor para implementar toJSONel método o implementar un replacermétodo. Para implementar toJSONel método, simplemente JSON.stringify()agregamos el siguiente código al archivo del programa antes de usar el método:

BigInt.prototype.toJSON = function () {
    
    
  return this.toString();
};

Para replacerimplementar el método usando JSON.stringify()el método, simplemente agregamos el siguiente código a nuestro programa:

const replacer = (key, value) => {
    
    
 return typeof value === "bigint" ? value.toString() : value
}

Podemos hacer esto usando cualquiera de los dos métodos siguientes JSON.stringify():

// 方法一
// 使用 toJSON

// 把这个放在使用 JSON.stringify() 的地方之前
BigInt.prototype.toJSON = function () {
    
    
  return this.toString();
};

const value1 = {
    
    one: 5n, two: 667n};
const value1ToJson = JSON.stringify(value1);
console.log(value1ToJson);
// {"one":"5","two":"667"}


// 方法二
// 使用 replacer
const replacer = (key, value) => {
    
    
 return typeof value === "bigint" ? value.toString() : value
}

const value2 = {
    
    seven: 7n, twenty: 20n, five: 5n};
const value2ToJson = JSON.stringify(value2, replacer);
console.log(value2ToJson);
// {"seven":"7","twenty":"20","five":"5"}

Limitaciones de BigInt

BigIntUna de las limitaciones es que no podemos utilizar funciones integradas en JavaScript Math. En lugar de ello, deberíamos construir las funciones matemáticas nosotros mismos. Por lo tanto, realizar Math.sqrt()una operación como ésta generará TypeErroruna excepción:

console.log(Math.sqrt(4n))
// TypeError: can't convert BigInt to number

Además, BigIntla división usando devuelve un resultado truncado. Debido a que BigIntlos valores no pueden ser decimales, las operaciones de división a veces devuelven dividendos decimales, por ejemplo 7 / 4 = 1.75. Por tanto, BigIntel valor siempre se redondeará a 0. Esto significa 7n / 4n = 1nmás de lo que se esperaba 1.75n.

Compatibilidad con navegador y Node.js

Se admite v10.4cualquier versión de Node.js desde entonces (incluidas las versiones más nuevas ) , por lo que las versiones anteriores generarán errores de sintaxis. Nuevamente, compatible con la mayoría de los navegadores modernos . Puedes ver los detalles en caniuse .v18.16BigIntBigInt

Al momento de escribir este artículo, más del 94% de los navegadores admiten BigIntconstructores y sus métodos.

resumen

En este artículo, aprendimos sobre BigIntsus métodos disponibles, casos de uso y problemas con su uso. Sin embargo, debemos saber que Numbertambién es útil para programas diarios como sitios web pequeños y debe usarse sólo cuando estemos seguros de que estamos ante grandes números BigInt.

gracias por leer. Espero que hayas disfrutado de este artículo y si tienes alguna pregunta, asegúrate de dejar un comentario.