JavaScript has come a long way since its inception, continuously evolving to meet the growing demands of modern web development. One of the most significant additions in recent years is the BigInt
primitive type, introduced in ECMAScript 2020 (ES11). This powerful feature allows developers to work with integers of arbitrary precision, overcoming the limitations of the traditional Number
type.
Understanding the Need for BigInt
Before we dive into the intricacies of BigInt
, let's understand why it was introduced in the first place.
🔢 In JavaScript, the Number
type is represented internally as a 64bit floatingpoint number, following the IEEE 754 standard. This representation has a limitation: it can only safely represent integers between (2^53 – 1) and (2^53 – 1).
Let's demonstrate this limitation:
const maxSafeInteger = Number.MAX_SAFE_INTEGER;
console.log(maxSafeInteger); // 9007199254740991
console.log(maxSafeInteger + 1); // 9007199254740992
console.log(maxSafeInteger + 2); // 9007199254740992 (Uhoh!)
As you can see, adding 1 to MAX_SAFE_INTEGER
works as expected, but adding 2 gives the same result! This is because JavaScript can no longer represent these large numbers accurately using the Number
type.
💡 This limitation becomes problematic in scenarios involving very large numbers, such as when working with cryptography, highprecision timestamps, or large scientific calculations.
Enter BigInt
– a new primitive type designed to represent integers of arbitrary precision.
Introducing BigInt
BigInt
is a builtin object that provides a way to represent whole numbers larger than 2^53 – 1. Let's explore how to create and use BigInt
values.
Creating BigInt Values
There are two ways to create a BigInt
:
 Appending 'n' to the end of an integer literal:
const bigInt = 1234567890123456789012345678901234567890n;
console.log(bigInt); // 1234567890123456789012345678901234567890n
 Using the
BigInt()
function:
const anotherBigInt = BigInt("9007199254740991");
console.log(anotherBigInt); // 9007199254740991n
🚨 Note: You cannot use the BigInt()
function with decimal numbers or nonnumeric strings. It will throw a SyntaxError
.
BigInt(10.5); // Uncaught SyntaxError: Cannot convert 10.5 to a BigInt
BigInt("10.5"); // Uncaught SyntaxError: Cannot convert 10.5 to a BigInt
BigInt("Hello"); // Uncaught SyntaxError: Cannot convert Hello to a BigInt
Operations with BigInt
Now that we know how to create BigInt
values, let's explore the operations we can perform with them.
Arithmetic Operations
BigInt
supports all the basic arithmetic operations:
const a = 1234567890123456789n;
const b = 9876543210987654321n;
console.log(a + b); // 11111111111111111110n
console.log(a  b); // 8641975320864197532n
console.log(a * b); // 12193263111263526900609714062n
console.log(a / b); // 0n (integer division)
console.log(a % b); // 1234567890123456789n
🔍 Notice that division with BigInt
always results in an integer, truncating any decimal part.
Comparison Operations
BigInt
values can be compared using the standard comparison operators:
console.log(1n < 2n); // true
console.log(2n > 1n); // true
console.log(2n >= 2n); // true
console.log(3n <= 2n); // false
console.log(2n === 2n); // true
console.log(2n === 2); // false (strict equality checks type as well)
console.log(2n == 2); // true (loose equality converts the number to BigInt)
💡 It's important to note that BigInt
and Number
are not strictly equal, even when they represent the same value. This is because they are different types.
Bitwise Operations
BigInt
supports all bitwise operations except unsigned right shift (>>>):
console.log(1n & 2n); // 0n
console.log(1n  2n); // 3n
console.log(1n ^ 2n); // 3n
console.log(~1n); // 2n
console.log(1n << 1n); // 2n
console.log(1n >> 1n); // 0n
🚨 Attempting to use >>>
with BigInt
will throw a TypeError
:
console.log(1n >>> 1n); // TypeError: BigInts have no unsigned right shift, use >> instead
BigInt in Practice
Let's explore some practical scenarios where BigInt
can be particularly useful.
Precise Financial Calculations
When dealing with large financial calculations, precision is crucial. BigInt
can help maintain accuracy:
function calculateCompoundInterest(principal, rate, time, compoundingFrequency) {
const p = BigInt(principal);
const r = BigInt(rate);
const t = BigInt(time);
const n = BigInt(compoundingFrequency);
// A = P(1 + r/n)^(nt)
const base = ((r * 100n) / (n * 10000n)) + 1n;
const exponent = n * t;
const amount = p * (base ** exponent) / (100n ** exponent);
return amount;
}
const principal = 1000000000000n; // $1 trillion
const rate = 5n; // 5%
const time = 30n; // 30 years
const compoundingFrequency = 12n; // monthly
const finalAmount = calculateCompoundInterest(principal, rate, time, compoundingFrequency);
console.log(`Final amount after ${time} years: $${finalAmount}`);
// Final amount after 30 years: $4321942014739n
This example demonstrates how BigInt
can be used to perform precise financial calculations with very large numbers, which would be impossible with regular Number
type due to precision loss.
Cryptography and Hashing
BigInt
is particularly useful in cryptography, where working with very large prime numbers is common. Here's a simple example of generating a large prime number:
function isPrime(n) {
if (n <= 1n) return false;
if (n <= 3n) return true;
if (n % 2n === 0n  n % 3n === 0n) return false;
for (let i = 5n; i * i <= n; i += 6n) {
if (n % i === 0n  n % (i + 2n) === 0n) return false;
}
return true;
}
function generateLargePrime(bits) {
while (true) {
const n = BigInt(Math.floor(Math.random() * (2 ** bits)))  1n;
if (isPrime(n)) return n;
}
}
const largePrime = generateLargePrime(1024);
console.log(`A 1024bit prime number: ${largePrime}`);
This example generates a large prime number, which could be used in various cryptographic applications.
Limitations and Considerations
While BigInt
is a powerful feature, it's important to be aware of its limitations:

🚫 No Decimal Point:
BigInt
can only represent whole numbers. If you need to work with fractional numbers, you'll need to use a different approach. 
⚠️ Type Coercion:
BigInt
values are not implicitly converted toNumber
values and vice versa. You need to explicitly convert between the two:
const bigInt = 10n;
const number = 5;
console.log(bigInt + BigInt(number)); // 15n
console.log(Number(bigInt) + number); // 15

🐌 Performance: Operations on
BigInt
values are slower than those onNumber
values. UseBigInt
only when necessary for large integer calculations. 
📊 Math Object: Many
Math
object methods are not compatible withBigInt
. For example,Math.round()
,Math.ceil()
,Math.floor()
, etc., will throw aTypeError
if used withBigInt
. 
🌐 JSON Serialization:
BigInt
values cannot be serialized in JSON. If you need to sendBigInt
values over the network, you'll need to convert them to strings first.
const bigInt = 1234567890123456789012345678901234567890n;
JSON.stringify({ bigInt }); // Throws TypeError: Do not know how to serialize a BigInt
To work around this, you can use a custom toJSON
method:
BigInt.prototype.toJSON = function() { return this.toString() };
console.log(JSON.stringify({ bigInt })); // {"bigInt":"1234567890123456789012345678901234567890"}
Browser and Environment Support
As of 2023, BigInt
is supported in all modern browsers and Node.js versions 10.4.0 and above. However, it's always a good practice to check for support, especially if your application needs to run in older environments:
if (typeof BigInt !== 'undefined') {
console.log("BigInt is supported");
} else {
console.log("BigInt is not supported in this environment");
}
Conclusion
BigInt
is a powerful addition to JavaScript that opens up new possibilities for working with large integers. Whether you're dealing with financial calculations, cryptography, or any other scenario involving very large numbers, BigInt
provides the precision and flexibility you need.
By understanding how to create and manipulate BigInt
values, as well as being aware of its limitations, you can leverage this feature to build more robust and accurate applications. As with any programming concept, practice and realworld application will help solidify your understanding of BigInt
.
Remember, while BigInt
is a valuable tool, it's not always necessary for every large number scenario. Use it judiciously, considering both the benefits and potential performance implications in your specific use case.
Happy coding with BigInt
! 🚀🔢