BigInt in JavaScript: Working with Large Integers

In JavaScript, dealing with very large or very small integers has traditionally been a challenge due to limitations in the Number data type. However, the introduction of BigInt offers a robust solution for working with integers beyond the safe range of Number.

When and How to Use BigInt

BigInt is a built-in object that provides a way to represent whole numbers larger than 2^53 – 1, which is the largest number JavaScript can reliably represent with the Number type.

I. How to Use BigInt

You can create a BigInt by appending n to the end of an integer literal or by calling the BigInt() function.

// Using BigInt literal
const bigIntLiteral = 1234567890123456789012345678901234567890n;

// Using BigInt function
const bigIntFromFunction = BigInt("1234567890123456789012345678901234567890");

Operations with BigInt

BigInt can be used in arithmetic operations just like Number, but with a few key differences.

I. Arithmetic Operations

You can use +, -, *, /, and % with BigInt, similar to Number. However, when performing operations involving both BigInt and Number types, you must explicitly convert Number to BigInt or vice versa, because JavaScript does not allow mixed-type arithmetic to prevent precision loss.

const bigInt1 = 123456789012345678901n;
const bigInt2 = 100n;

console.log(bigInt1 + bigInt2); // 12345678901234567890101n

II. Comparisons

BigInt can be compared to other BigInt values using comparison operators. Comparing a BigInt to a Number is also allowed without explicit conversion, as long as the comparison does not involve arithmetic operations.

console.log(10n < 20n); // true
console.log(10n === 10); // false, different types
console.log(10n == 10); // true, value is the same when abstract equality is used

Limitations of BigInt Compared to Number

While BigInt addresses the need for working with very large integers, it has limitations and differences compared to Number.

  1. Precision: BigInt allows for arbitrary precision, meaning it can represent very large numbers without losing accuracy, unlike Number which can lose precision with very large or very small values.
  2. Not Usable with Math Object: The Math object’s methods don’t work with BigInt. For mathematical operations on BigInt, you must use its operators or work with libraries designed for BigInt.
  3. JSON Serialization: BigInt is not serializable to JSON using JSON.stringify() directly, which means you may need to convert it to a string or another format before serialization.
  4. Performance: Operations with BigInt might be slower than with Number, especially as the size of the integers increases. This is due to the additional computational overhead required for arbitrary precision arithmetic.


BigInt offers a powerful solution for working with large integers in JavaScript, filling a gap that the Number type couldn’t address due to its limitations. By understanding how to use BigInt, its operations, and its limitations, you can confidently work with large integers in your JavaScript applications, whether for financial calculations, cryptography, or any domain requiring high-precision integer arithmetic.