JavaScript BigInt: освоение арифметики больших целых чисел

JavaScript, будучи универсальным языком, имеет ограничения при работе с очень большими целыми числами. Стандартный тип `Number` может точно представлять целые числа только до определенного предела, известного как `Number.MAX_SAFE_INTEGER`. За этим пределом вычисления становятся неточными, что приводит к неожиданным результатам. Именно здесь на помощь приходит BigInt. Представленный в ECMAScript 2020, BigInt — это встроенный объект, который предоставляет способ представления и манипулирования целыми числами произвольного размера, превышая ограничения стандартного типа `Number`.

Понимание необходимости BigInt

До появления BigInt разработчикам JavaScript приходилось полагаться на библиотеки или собственные реализации для обработки вычислений с большими целыми числами. Эти решения часто сопровождались снижением производительности и повышенной сложностью. Введение BigInt предоставило нативный и эффективный способ работы с большими целыми числами, открывая возможности для приложений в различных областях, включая:

Криптография: Безопасная обработка больших простых чисел имеет решающее значение для криптографических алгоритмов.
Финансовые расчеты: Точное представление больших денежных сумм без потери точности.
Научные вычисления: Выполнение сложных расчетов с участием чрезвычайно больших или малых чисел.
Высокоточные временные метки: Представление временных меток с наносекундной точностью.
Генерация идентификаторов: Создание уникальных и очень больших идентификаторов.

Создание значений BigInt

Существует два основных способа создания значений BigInt в JavaScript:

Использование конструктора `BigInt()`: Этот конструктор может преобразовать число, строку или логическое значение в BigInt.
Использование суффикса `n`: Добавление `n` к целочисленному литералу создает BigInt.

Примеры:

Использование конструктора `BigInt()`:


const bigIntFromNumber = BigInt(12345678901234567890);
const bigIntFromString = BigInt("98765432109876543210");
const bigIntFromBoolean = BigInt(true); // Результат: 1n
const bigIntFromFalseBoolean = BigInt(false); // Результат: 0n

console.log(bigIntFromNumber); // Вывод: 12345678901234567890n
console.log(bigIntFromString); // Вывод: 98765432109876543210n
console.log(bigIntFromBoolean); // Вывод: 1n
console.log(bigIntFromFalseBoolean); // Вывод: 0n

Использование суффикса `n`:


const bigIntLiteral = 12345678901234567890n;
console.log(bigIntLiteral); // Вывод: 12345678901234567890n

Важное замечание: Вы не можете напрямую смешивать значения BigInt и Number в арифметических операциях. Вам необходимо явно преобразовать их к одному типу перед выполнением вычислений. Попытка смешать их напрямую приведет к ошибке `TypeError`.

Арифметические операции с BigInt

BigInt поддерживает большинство стандартных арифметических операторов, включая:

Сложение (`+`)
Вычитание (`-`)
Умножение (`*`)
Деление (`/`)
Остаток от деления (`%`)
Возведение в степень (`**`)

Примеры:


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

const sum = a + b;
const difference = a - b;
const product = a * b;
const quotient = a / 2n; // Примечание: Деление усекает дробную часть (округляет к нулю)
const remainder = a % 7n;
const power = a ** 3n; // Возведение в степень работает как ожидалось

console.log("Сумма:", sum); // Вывод: Сумма: 111111111011111111100n
console.log("Разность:", difference); // Вывод: Разность: -86419753208641975320n
console.log("Произведение:", product); // Вывод: Произведение: 1219326311370217957951669538098765432100n
console.log("Частное:", quotient); // Вывод: Частное: 6172839450617283945n
console.log("Остаток:", remainder); // Вывод: Остаток: 5n
console.log("Степень:", power); // Вывод: Степень: 187641281029182300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

Важные соображения:

Деление: Деление со значениями BigInt усекает дробную часть (округляет к нулю). Это означает, что десятичная часть результата отбрасывается. Если вам нужно более точное деление, рассмотрите возможность использования библиотек, поддерживающих арифметику с произвольной точностью.
Унарный оператор плюс (+): Унарный оператор плюс (+) не может использоваться со значениями BigInt, поскольку это может конфликтовать со старым кодом asm.js. Используйте функцию преобразования `Number()` для конвертации BigInt в Number, если вам требуется числовое представление (понимая, что вы можете потерять точность).
Побитовые операторы: BigInt также поддерживает побитовые операторы, такие как `&`, `|`, `^`, `~`, `<<` и `>>`. Эти операторы работают как ожидалось с двоичным представлением значений BigInt.

Операторы сравнения

Вы можете использовать стандартные операторы сравнения (`==`, `!=`, `<`, `>`, `<=`, `>=`) для сравнения значений BigInt с другими значениями BigInt или даже со значениями Number. Однако помните о возможности приведения типов.

Примеры:


const a = 10n;
const b = 20n;
const c = 10;

console.log(a == b);   // Вывод: false
console.log(a != b);   // Вывод: true
console.log(a < b);    // Вывод: true
console.log(a > b);    // Вывод: false
console.log(a <= b);   // Вывод: true
console.log(a >= b);   // Вывод: false

console.log(a == c);   // Вывод: true (приведение типов)
console.log(a === c);  // Вывод: false (без приведения типов)

Лучшая практика: Используйте строгое равенство (`===`) и строгое неравенство (`!==`), чтобы избежать неожиданного приведения типов при сравнении значений BigInt и Number.

Преобразование между BigInt и Number

Хотя прямые арифметические операции между BigInt и Number не допускаются, вы можете выполнять преобразование между этими двумя типами. Однако будьте осведомлены о потенциальной потере точности при преобразовании BigInt в Number, если значение BigInt превышает `Number.MAX_SAFE_INTEGER`.

Примеры:


const bigIntValue = 9007199254740991n; // Number.MAX_SAFE_INTEGER
const numberValue = Number(bigIntValue); // Преобразование BigInt в Number
console.log(numberValue); // Вывод: 9007199254740991

const largerBigIntValue = 9007199254740992n; // Превышает Number.MAX_SAFE_INTEGER
const largerNumberValue = Number(largerBigIntValue);
console.log(largerNumberValue); // Вывод: 9007199254740992 (может быть неточным)

const numberToBigInt = BigInt(12345); // Преобразование Number в BigInt
console.log(numberToBigInt); // Вывод: 12345n

Сценарии использования и примеры

Криптография

Криптографические алгоритмы часто полагаются на очень большие простые числа для обеспечения безопасности. BigInt предоставляет способ эффективного представления и манипулирования этими числами.


// Пример: Генерация простой (небезопасной) пары ключей
function generateKeyPair() {
  const p = 281n; // Простое число
  const q = 283n; // Другое простое число
  const n = p * q; // Модуль
  const totient = (p - 1n) * (q - 1n); // Функция Эйлера

  // Выбираем e (открытая экспонента) так, чтобы 1 < e < totient и gcd(e, totient) = 1
  const e = 17n;

  // Вычисляем d (секретная экспонента) так, чтобы (d * e) % totient = 1
  let d = 0n;
  for (let i = 1n; i < totient; i++) {
    if ((i * e) % totient === 1n) {
      d = i;
      break;
    }
  }

  return {
    publicKey: { n, e },
    privateKey: { n, d },
  };
}

const keyPair = generateKeyPair();
console.log("Открытый ключ:", keyPair.publicKey);
console.log("Закрытый ключ:", keyPair.privateKey);

Примечание: Это упрощенный пример только для демонстрационных целей. В реальной криптографии используются гораздо большие простые числа и более сложные алгоритмы.

Финансовые расчеты

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


// Пример: Расчет сложных процентов
function calculateCompoundInterest(principal, rate, time) {
  const principalBigInt = BigInt(principal * 100); // Преобразуем в центы
  const rateBigInt = BigInt(rate * 10000);       // Преобразуем в десятитысячные доли процента
  const timeBigInt = BigInt(time);

  let amount = principalBigInt;
  for (let i = 0n; i < timeBigInt; i++) {
    amount = amount * (10000n + rateBigInt) / 10000n;
  }

  const amountInDollars = Number(amount) / 100;
  return amountInDollars;
}

const principal = 1000000; // $1,000,000
const rate = 0.05;    // 5% процентная ставка
const time = 10;     // 10 лет

const finalAmount = calculateCompoundInterest(principal, rate, time);
console.log("Итоговая сумма:", finalAmount); // Вывод: Итоговая сумма: 1628894.6267774413 (приблизительно)

В этом примере мы преобразуем основную сумму и ставку в значения BigInt, чтобы избежать ошибок округления во время расчета. Затем результат преобразуется обратно в Number для отображения.

Работа с большими идентификаторами

В распределенных системах генерация уникальных идентификаторов на нескольких серверах может быть сложной задачей. Использование BigInt позволяет создавать очень большие идентификаторы, которые вряд ли будут конфликтовать.


// Пример: Генерация уникального ID на основе временной метки и ID сервера
function generateUniqueId(serverId) {
  const timestamp = BigInt(Date.now());
  const serverIdBigInt = BigInt(serverId);
  const random = BigInt(Math.floor(Math.random() * 1000)); // Добавляем немного случайности

  // Объединяем значения для создания уникального ID
  const uniqueId = (timestamp << 20n) + (serverIdBigInt << 10n) + random;
  return uniqueId.toString(); // Возвращаем в виде строки для удобства обработки
}

const serverId = 123; // Пример ID сервера
const id1 = generateUniqueId(serverId);
const id2 = generateUniqueId(serverId);

console.log("Уникальный ID 1:", id1);
console.log("Уникальный ID 2:", id2);

BigInt и JSON

Значения BigInt не поддерживаются в JSON нативно. Попытка сериализовать объект JavaScript, содержащий BigInt, с помощью `JSON.stringify()` приведет к ошибке `TypeError`. Для обработки значений BigInt при работе с JSON у вас есть несколько вариантов:

Преобразование в строку: Преобразуйте BigInt в строку перед сериализацией. Это самый распространенный и простой подход.
Пользовательская сериализация/десериализация: Используйте пользовательскую функцию сериализации/десериализации для обработки значений BigInt.

Примеры:

Преобразование в строку:


const data = {
  id: 12345678901234567890n,
  name: "Example Data",
};

// Преобразуем BigInt в строку перед сериализацией
data.id = data.id.toString();

const jsonData = JSON.stringify(data);
console.log(jsonData); // Вывод: {"id":"12345678901234567890","name":"Example Data"}

// При десериализации вам нужно будет преобразовать строку обратно в BigInt
const parsedData = JSON.parse(jsonData, (key, value) => {
  if (key === "id") {
    return BigInt(value);
  }
  return value;
});

console.log(parsedData.id); // Вывод: 12345678901234567890n

Пользовательская сериализация/десериализация (с использованием `replacer` и `reviver`):


const data = {
  id: 12345678901234567890n,
  name: "Example Data",
};

// Пользовательская сериализация
const jsonData = JSON.stringify(data, (key, value) => {
  if (typeof value === 'bigint') {
    return value.toString();
  } else {
    return value;
  }
});

console.log(jsonData);

// Пользовательская десериализация
const parsedData = JSON.parse(jsonData, (key, value) => {
    if (typeof value === 'string' && /^[0-9]+$/.test(value)) { //проверяем, является ли значение строкой и числом
      try {
        return BigInt(value);
      } catch(e) {
          return value;
      }
    }
    return value;
});

console.log(parsedData.id);

Совместимость с браузерами

BigInt широко поддерживается в современных браузерах. Однако важно проверять совместимость со старыми браузерами или средами. Вы можете использовать инструмент вроде Can I use для проверки поддержки браузерами. Если вам необходимо поддерживать старые браузеры, вы можете рассмотреть возможность использования полифилла, но имейте в виду, что полифиллы могут повлиять на производительность.

Вопросы производительности

Хотя BigInt предоставляет мощный способ работы с большими целыми числами, важно помнить о возможных последствиях для производительности.

Операции с BigInt могут быть медленнее, чем стандартные операции с Number.
Преобразование между BigInt и Number также может создавать дополнительную нагрузку.

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

Заключение

BigInt — это ценное дополнение к JavaScript, позволяющее разработчикам с точностью обрабатывать арифметику больших целых чисел. Понимая его возможности, ограничения и сценарии использования, вы можете использовать BigInt для создания надежных и точных приложений в различных областях, включая криптографию, финансовые расчеты и научные вычисления. Не забывайте учитывать совместимость с браузерами и последствия для производительности при использовании BigInt в своих проектах.

Для дальнейшего изучения

Это руководство представляет собой всеобъемлющий обзор BigInt в JavaScript. Изучите приведенные ресурсы для получения более подробной информации и продвинутых техник.