Home > Article > Web Front-end > Understanding BigInt in JavaScript
In JavaScript, numbers have traditionally been represented using the Number type, which adheres to the IEEE 754 standard for double-precision floating-point arithmetic. This representation, while versatile, has a limitation: it can safely represent integers only up to (2^{53} - 1) (or (9,007,199,254,740,991)). For applications requiring larger integers, JavaScript introduces a solution through the BigInt type.
BigInt is a built-in object in JavaScript that provides a way to represent whole numbers larger than those that can be handled by the Number type. Unlike Number, which is suitable for floating-point arithmetic and can handle values between approximately (-1.8 times 10^{308}) and (1.8 times 10^{308}), BigInt is designed specifically for arbitrary-precision integer arithmetic.
There are a couple of ways to create BigInt values:
const bigIntValue = BigInt(123456789012345678901234567890);
Note that BigInt accepts strings and numbers, but when using numbers, they should be within the range of a Number type.
const bigIntLiteral = 123456789012345678901234567890n;
This is a more concise way to define BigInt values directly.
BigInt supports most of the standard arithmetic operators. Here’s a brief overview:
const a = 10n; const b = 20n; const sum = a + b; // 30n
const difference = b - a; // 10n
const product = a * b; // 200n
const quotient = b / 3n; // 6n (Note: Division results in a `BigInt` which is truncated towards zero)
const remainder = b % 3n; // 2n
const power = a ** 3n; // 1000n
BigInt can be compared using the standard comparison operators. Note that BigInt values and Number values are not directly comparable:
const a = 10n; const b = 10; console.log(a == b); // false console.log(a === BigInt(b)); // true
Conversion between BigInt and Number can be done using explicit conversion methods:
const bigIntValue = 123n; const numberValue = Number(bigIntValue);
Note: This can lose precision if the BigInt value is too large.
const numberValue = 123; const bigIntValue = BigInt(numberValue);
const a = 10n; const b = 5; // The following line will throw a TypeError const result = a + b;
const bigIntValue = 123n; JSON.stringify(bigIntValue); // Throws TypeError
To handle BigInt in JSON, you may need to convert it to a string first:
const bigIntValue = 123n; const jsonString = JSON.stringify({ value: bigIntValue.toString() });
BigInt is particularly useful in scenarios where precision with large integers is crucial, such as:
BigInt is a powerful addition to JavaScript, expanding its capabilities for handling integers beyond the limits of the Number type. Understanding its operations, limitations, and appropriate use cases can help in leveraging its benefits for applications requiring large integer calculations.
The above is the detailed content of Understanding BigInt in JavaScript. For more information, please follow other related articles on the PHP Chinese website!