BigInt() - функция для создания больших целых чисел в JavaScript

BigInt() создаёт значение типа bigint.

Этот тип нужен для работы с большими целыми числами, когда обычный number уже может терять точность.

BigInt() подходит только для целых чисел. Дробные значения через него получить нельзя.

Синтаксис

BigInt(value)

value обычно бывает строкой, числом или boolean.

В отличие от Number() или Boolean(), вызов BigInt() без аргумента приводит к ошибке:

// BigInt(); // TypeError

Что делает BigInt()

BigInt() преобразует значение в тип bigint.

console.log(BigInt(10));    // 10n
console.log(BigInt("123")); // 123n
console.log(BigInt(true));  // 1n
console.log(BigInt(false)); // 0n

Результат всегда имеет тип bigint.

const result = BigInt("42");

console.log(result);        // 42n
console.log(typeof result); // "bigint"

Зачем нужен BigInt()

Тип number безопасно хранит целые числа только до Number.MAX_SAFE_INTEGER.

console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991

Если число больше, обычный number может потерять точность.

console.log(9007199254740993); // 9007199254740992

BigInt нужен именно для таких случаев:

console.log(BigInt("9007199254740993")); // 9007199254740993n

Если значение уже слишком большое, безопаснее передавать его строкой, а не числом.

Строки

BigInt() умеет превращать строку в большое целое число, если строка содержит корректное целое значение.

console.log(BigInt("123"));   // 123n
console.log(BigInt("-50"));   // -50n
console.log(BigInt(" 10 "));  // 10n

Строка должна быть именно целым числом.

// BigInt("10.5"); // SyntaxError
// BigInt("10n");  // SyntaxError

Это важный момент: суффикс n используют в коде для литерала, но не внутри строки.

Числа

Если передать обычное число, BigInt() сработает только для целого значения.

console.log(BigInt(10));   // 10n
console.log(BigInt(-25));  // -25n

Дробные числа, NaN и Infinity не подходят:

// BigInt(10.5);     // RangeError
// BigInt(NaN);      // RangeError
// BigInt(Infinity); // RangeError

Осторожно с большими number

Это одна из самых частых ловушек.

console.log(BigInt(9007199254740993));    // 9007199254740992n
console.log(BigInt("9007199254740993"));  // 9007199254740993n

Во втором примере результат точный, потому что строка не теряет значение заранее.

Если большое число приходит извне или может быть больше безопасного диапазона, лучше сразу хранить его как строку и потом превращать через BigInt().

Boolean

Булевы значения преобразуются так:

console.log(BigInt(true));  // 1n
console.log(BigInt(false)); // 0n

null, undefined и Symbol

Некоторые значения в bigint не преобразуются:

// BigInt(null);      // TypeError
// BigInt(undefined); // TypeError
// BigInt(Symbol("id")); // TypeError

BigInt и арифметика

С bigint можно выполнять обычные арифметические операции, если оба операнда тоже bigint.

console.log(2n + 3n); // 5n
console.log(2n * 3n); // 6n
console.log(7n - 2n); // 5n

Деление тоже работает, но результат всегда остаётся целым:

console.log(5n / 2n); // 2n

Дробной части здесь не будет.

BigInt и Number

bigint и number - это разные типы, и автоматически смешивать их в арифметике нельзя.

// console.log(1n + 1); // TypeError

Если нужно, типы приводят явно:

console.log(1n + BigInt(1)); // 2n
console.log(Number(10n) + 5); // 15

Но при переводе большого bigint в number можно потерять точность:

console.log(Number(9007199254740993n)); // 9007199254740992

Сравнение BigInt и Number

При сравнении тоже есть нюанс:

console.log(1n == 1);  // true
console.log(1n === 1); // false

== пытается сравнить значения, а === ещё и проверяет тип.

Поэтому для предсказуемого кода лучше помнить, что bigint и number - это не одно и то же.

BigInt() и new BigInt()

BigInt() нельзя вызывать с new.

// new BigInt(10); // TypeError

В отличие от Number() или Boolean(), здесь вообще нет объекта-обёртки, который стоило бы создавать.

Используют только обычный вызов:

const id = BigInt("12345678901234567890");

BigInt и JSON

У BigInt есть важное ограничение: JSON.stringify() не умеет сериализовать его напрямую.

const user = { id: 1n };

// JSON.stringify(user); // TypeError

Обычно в таких случаях значение заранее превращают в строку:

const user = { id: 1n };

console.log(JSON.stringify({ id: String(user.id) }));
// {"id":"1"}

Когда это полезно

BigInt() удобно использовать, когда:

• нужно хранить очень большие целые числа без потери точности
• важна точная работа именно с целыми значениями
• число приходит строкой из базы данных, файла или внешнего сервиса
• обычный number уже не подходит из-за ограничения MAX_SAFE_INTEGER

Пример:

const orderId = BigInt("98765432101234567890");

console.log(orderId);        // 98765432101234567890n
console.log(typeof orderId); // "bigint"

Частые ошибки

Передавать дробное число

// BigInt(10.5); // RangeError

BigInt() работает только с целыми значениями.

Передавать большую number-переменную вместо строки

console.log(BigInt(9007199254740993));   // 9007199254740992n
console.log(BigInt("9007199254740993")); // 9007199254740993n

Если число уже попало в number, точность могла потеряться ещё до вызова BigInt().

Писать "10n" внутри строки

// BigInt("10n"); // SyntaxError

Для строки нужен просто текст числа:

console.log(BigInt("10")); // 10n

Смешивать bigint и number в арифметике

// console.log(1n + 1); // TypeError

Нужно сначала привести один тип к другому.

Ожидать дробный результат от деления

console.log(5n / 2n); // 2n

BigInt хранит только целые значения, поэтому дробная часть отбрасывается.

Использовать JSON.stringify() напрямую

const user = { id: 1n };

// JSON.stringify(user); // TypeError

Для JSON bigint обычно превращают в строку.

Быстрая памятка

• BigInt(value) создаёт значение типа bigint
• BigInt() без аргумента даёт ошибку
• тип подходит только для целых чисел
• большие значения безопаснее передавать строкой
• bigint и number нельзя смешивать в арифметике без явного преобразования
• new BigInt() использовать нельзя
• JSON.stringify() не умеет сериализовать bigint напрямую

Коротко

BigInt() - это стандартный способ получить точное большое целое число в JavaScript. Главное, что стоит запомнить: BigInt нужен именно для целых значений, большие числа безопаснее передавать строкой, bigint нельзя смешивать с number без явного приведения, а new BigInt() и прямой JSON.stringify() для него не подходят.