JavaScript BigInt

BigInt is a built-in numeric primitive in JavaScript that provides a way to represent and manipulate whole numbers larger than 2⁵³ - 1. This value represents the Number.MAX_SAFE_INTEGER limit dictated by the IEEE 754 double-precision floating-point format, which the standard Number type uses. BigInt enables arbitrary-precision integer arithmetic, preventing the silent precision loss that occurs when standard numbers exceed the safe integer threshold.

Instantiation and Syntax

A BigInt is created either by appending the suffix n to an integer literal or by invoking the BigInt() function. Unlike Number, String, or Boolean, invoking BigInt with the new keyword throws a TypeError. The ECMAScript specification explicitly forbids constructor usage for BigInt (similar to Symbol) to avoid the historical pitfalls and confusion associated with primitive object wrappers.

// Literal syntax
const maxSafe = 9007199254740991n;
const beyondSafe = 9007199254740992n;

// Function syntax
const fromNumber = BigInt(15);
const fromString = BigInt("90071992547409923456789");
const fromHex = BigInt("0x1fffffffffffff");

// TypeError: BigInt is not a constructor
const invalidObject = new BigInt(10); 

Type Identification

The typeof operator returns a distinct string for BigInt values, separating them from standard floating-point numbers.

typeof 10;  // "number"
typeof 10n; // "bigint"

Arithmetic Operations

BigInt supports standard arithmetic operators (+, -, *, /, %, **). However, because BigInt strictly represents integers, division operations do not return fractional values. Instead, the result is truncated towards zero. A critical exception in BigInt arithmetic is the unary plus operator (+). While commonly used to coerce values to numbers, unary plus is explicitly not supported for BigInt and will throw a TypeError.

const a = 10n;
const b = 3n;

const sum = a + b;       // 13n
const product = a * b;   // 30n
const quotient = a / b;  // 3n (fractional part is discarded)
const remainder = a % b; // 1n
const power = a ** b;    // 1000n

// TypeError: Cannot convert a BigInt value to a number
const invalidUnary = +a; 

Type Mixing and Coercion

JavaScript prohibits implicit coercion between BigInt and Number during arithmetic operations to prevent accidental precision loss. Attempting to mix the two types throws a TypeError. Explicit casting is required.

const bigValue = 100n;
const numValue = 25;

// TypeError: Cannot mix BigInt and other types, use explicit conversions
const invalidMath = bigValue + numValue; 

// Valid: Explicitly cast Number to BigInt
const safeBigIntMath = bigValue + BigInt(numValue); // 125n

// Valid: Explicitly cast BigInt to Number (Risk of precision loss if > 2^53 - 1)
const safeNumberMath = Number(bigValue) + numValue; // 125

Comparisons

Relational operators (<, >, >=, <=) allow mixed-type comparisons without explicit coercion. Equality operators behave according to standard JavaScript strictness rules: strict equality (===) checks both value and type, while loose equality (==) coerces the values before comparing.

10n === 10; // false (different types: bigint vs number)
10n == 10;  // true (loose equality allows implicit coercion)

10n > 5;    // true
10n < 15.5; // true

Technical Limitations

Math Object Incompatibility: BigInt values cannot be passed to methods of the built-in Math object (e.g., Math.max(), Math.pow()). Doing so throws a TypeError.
Serialization: The standard JSON.stringify() method does not know how to serialize BigInt values by default and will throw a TypeError. To serialize a BigInt, you must implement a custom replacer function or patch the BigInt.prototype.toJSON method to return a string representation.
Bitwise Operations: Bitwise operators (|, &, <<, >>, ^, ~) are fully supported, but zero-fill right shift (>>>) is not, as BigInt does not have a fixed width and always maintains its sign bit.

Tired of Poor JavaScript Skills? Fix That With Deep Grasping!Learn More

Functions

Methods

Constructors

Classes

Destructuring

Decorators

Modules

Accessors

Variables

Fields

Parameters

Error Handling

Control Flow

Statement Forms

Loops

Primitive Types

Comments

Access Operators

Spread Operators

Call Operators

Conditional Operators

Logical Operators

Equality Operators

Relational Operators

Arithmetic Operators

Assignment Operators

Update Operators

Unary Operators

Yield Operators

Bitwise Operators

Shift Operators

Instantiation and Syntax

Type Identification

Arithmetic Operations

Type Mixing and Coercion

Comparisons

Technical Limitations

​Instantiation and Syntax

​Type Identification

​Arithmetic Operations

​Type Mixing and Coercion

​Comparisons

​Technical Limitations

Instantiation and Syntax

Type Identification

Arithmetic Operations

Type Mixing and Coercion

Comparisons

Technical Limitations