BigInt

BigInt is a built-in JavaScript primitive type introduced in ECMAScript 2020 to represent arbitrary-precision integers.

Unlike the Number type, which is limited to 64-bit floating-point values and has a safe integer range from Number.MIN_SAFE_INTEGER (-2^53 + 1) to Number.MAX_SAFE_INTEGER (2^53 - 1), BigInt can handle integers of any size without precision loss.

It is especially useful in cryptography, financial applications, and unique identifier generation.

Creating BigInt Values

Using the BigInt() Constructor

Converts a number, string, or boolean into a BigInt.

console.log(BigInt(123));           // 123n
console.log(BigInt("9007199254740992")); // 9007199254740992n
console.log(BigInt(true));          // 1n

Using the n Suffix

Appending n to an integer literal creates a BigInt directly.

console.log(123n);                  // 123n
console.log(9007199254740992n);     // 9007199254740992n

Operations with BigInt

BigInt supports arithmetic, comparison, and bitwise operations — but only with other BigInt values.

Arithmetic Operators

Supported operators: +, -, *, /, %, **

let a = 9007199254740991n;
let b = 2n;

console.log(a + b);   // 9007199254740993n
console.log(a * b);   // 18014398509481982n
console.log(a ** b);  // 81129638414606663681390495662081n

Division

Division always truncates toward zero (no fractional results).

console.log(10n / 3n); // 3n
console.log(10n % 3n); // 1n

Comparison Operators

BigInt and Number can be compared, but strict equality checks type as well.

console.log(123n === 123); // false
console.log(123n == 123);  // true
console.log(123n > 100);   // true

Bitwise Operators

Supported: &, |, ^, ~, <<, >>

console.log(123n & 456n); // 72n

BigInt and Math Methods

Most Math methods do not support BigInt, as they are designed for floating-point Numbers.

Example

console.log(Math.sqrt(16n));  // TypeError
console.log(Math.random() * 10n); // TypeError

Workaround

Convert to Number when within safe limits:

let big = 16n;
if (big <= BigInt(Number.MAX_SAFE_INTEGER)) {
  console.log(Math.sqrt(Number(big))); // 4
}

Random BigInt Example

Since Math.random() returns a Number, custom logic is required:

function getRandomBigInt(min, max) {
  min = BigInt(min);
  max = BigInt(max);
  let range = max - min + 1n;
  let random = BigInt(Math.floor(Math.random() * Number(range)));
  return min + random;
}
console.log(getRandomBigInt(1n, 10n)); // e.g., 7n

BigInt and Number Object

Type Checking

console.log(typeof 123n);     // 'bigint'
console.log(typeof 123);      // 'number'
console.log(Number.isNaN(123n)); // false
console.log(Number.isFinite(Number(123n))); // true

Conversion Between BigInt and Number

To Number:

let big = 123n;
console.log(Number(big)); // 123
console.log(+big);        // 123

To BigInt:

console.log(BigInt(123)); // 123n

Converting large BigInt to Number can cause precision loss:

let large = 9007199254740992n;
console.log(Number(large) === Number(large + 1n)); // true

Safe conversion:

function safeToNumber(big) {
  if (big <= BigInt(Number.MAX_SAFE_INTEGER) && big >= BigInt(Number.MIN_SAFE_INTEGER)) {
    return Number(big);
  }
  return null;
}

Formatting:

let big = 123456789n;
console.log(Number(big).toLocaleString()); // '123,456,789'

Common Pitfalls with BigInt

Mixing BigInt and Number

console.log(123n + 123); //  TypeError
console.log(123n + BigInt(123)); //  246n
console.log(Number(123n) + 123); //  246

Using BigInt with Math Methods

console.log(Math.random() * 100n); //  TypeError

Precision Loss

let big = 9007199254740992n;
console.log(Number(big + 1n) === Number(big)); // true

No Floating-Point Support

console.log(BigInt(12.34)); //  RangeError
console.log(BigInt(Math.floor(12.34))); //  12n

String Formatting Limitations

console.log(123n.toFixed(2)); //  TypeError
console.log(Number(123n).toFixed(2)); //  '123.00'