JavaScript BigInt: Handling Large Integers

JavaScript Number can represent integers exactly only up to Number.MAX_SAFE_INTEGER (2^53 - 1). When you need larger integer values without losing precision, use BigInt. Create a BigInt const a = 123456789012345678901234567890n; const b = BigInt('123456789012345678901234567890'); The n suffix creates a BigInt literal. BigInt() is useful when converting a string or an integer-valued Number.

Updated 07 Sep 2025

JavaScript Number can represent integers exactly only up to Number.MAX_SAFE_INTEGER (2^53 - 1). When you need larger integer values without losing precision, use BigInt.

Create a BigInt

const a = 123456789012345678901234567890n;
const b = BigInt('123456789012345678901234567890');

The n suffix creates a BigInt literal. BigInt() is useful when converting a string or an integer-valued Number.

Arithmetic

const a = 12345678901234567890n;
const b = 98765432109876543210n;

console.log(a + b); // 111111111011111111100n
console.log(b / a); // 8n

BigInt division truncates the fractional part toward zero:

console.log(7n / 2n); // 3n

Comparisons

console.log(1000n < 2000n);    // true
console.log(1000n === 1000n);  // true
console.log(1000n === 1000);   // false
console.log(1000n == 1000);    // true, due to coercion

Prefer strict equality unless coercion is intentional.

Convert Between `Number` and `BigInt`

const value = BigInt(42); // 42n

Converting a large BigInt to Number can lose precision:

const large = 12345678901234567890n;
const number = Number(large);

Also, arithmetic cannot mix Number and BigInt directly:

// 1n + 1 // TypeError
1n + BigInt(1); // 2n

JSON Serialization

JSON.stringify does not serialize BigInt values directly. Convert them to strings or provide a replacer:

const payload = { value: 9007199254740993n };

const json = JSON.stringify(payload, (_, value) =>
  typeof value === 'bigint' ? value.toString() : value
);

The receiving side must know that the string represents an integer and convert it back when appropriate.

When BigInt Is Useful

BigInt is useful for database IDs larger than JavaScript’s safe integer range, counters, timestamps or protocol fields that use 64-bit integers, and algorithms that genuinely require arbitrary-size integers.

It is not automatically the right choice for financial decimal arithmetic: BigInt stores integers, not decimal fractions. Financial applications often represent minor units as integers or use a decimal arithmetic library.

Conclusion

Use BigInt when exact integer values can exceed JavaScript’s safe Number range. Keep it separate from floating-point arithmetic, convert explicitly at boundaries, and define a serialization strategy for APIs and JSON.

JavaScript

Access JavaScript Array Elements with `at()`

Array.prototype.at() returns the element at a given integer index. Its main advantage over bracket notation is support for negative indexes. Positive Indexes const fruits = ['apple', 'banana', 'cherry']; console.log(fruits.at(0)); // 'apple' console.log(fruits.at(1)); // 'banana' Negative Indexes console.log(fruits.at(-1)); // 'cherry' console.log(fruits.at(-2)); // 'banana' Without at(), the traditional equivalent for the last element is:

Get Every RegExp Match with `String.matchAll()`

String.prototype.matchAll() returns an iterator containing every match of a global regular expression, including capturing groups and match indexes. const text = 'Order #123, Order #456, Order #789'; const regex = /Order #(\d+)/g; for (const match of text.matchAll(regex)) { console.log(match[0], match[1], match.index); } Named Capturing Groups const text = 'John: 123, Jane: 456'; const regex = /(?<name>\w+): (?<number>\d+)/g; for (const match of text.matchAll(regex)) { console.log(match.groups.name, match.groups.number); } Convert the Iterator to an Array const matches = [...'cat bat mat'.matchAll(/\b(\w+)at\b/g)]; This is convenient when you need map, filter, or other array operations, but iterating directly avoids storing all matches at once.

Handle Multiple Promises with `Promise.allSettled()`

Promise.allSettled() waits until every input promise has either fulfilled or rejected, then returns the outcome of each operation. Unlike Promise.all(), one rejection does not stop you from receiving the other results. const tasks = [ Promise.resolve('first result'), Promise.reject(new Error('second failed')), Promise.resolve('third result'), ]; const results = await Promise.allSettled(tasks); for (const result of results) { if (result.status === 'fulfilled') { console.log('Value:', result.value); } else { console.error('Error:', result.reason); } } Each result has one of these shapes: