Где брать дополнительные размеры для записи Infinity если закончились биты и байты?

Представление Infinity в JavaScript и динамические структуры данных

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

Как JavaScript представляет Infinity

Встроенное представление на уровне IEEE 754

JavaScript использует стандарт IEEE 754 для представления чисел с плавающей точкой (64-битные double). Infinity - это специальное значение, которое уже зарезервировано в этом стандарте:

console.log(Infinity); // Infinity
console.log(typeof Infinity); // "number"
console.log(1/0); // Infinity
console.log(-1/0); // -Infinity

// Infinity уже имеет представление в памяти
const buffer = new ArrayBuffer(8);
const view = new Float64Array(buffer);
view[0] = Infinity;
console.log(view[0]); // Infinity (8 байт достаточно)

В IEEE 754, Infinity кодируется как:

• Все биты экспоненты установлены в 1
• Все биты мантиссы равны 0

[Знак] [Экспонента: все 1] [Мантисса: все 0]
    1         11111111111            0000...

Если нужны числа больше Infinity

BigInt для целых чисел

Для работы с числами, которые больше чем Number.MAX_VALUE (но не Infinity), используется BigInt:

const huge = BigInt("999999999999999999999999999999999999");
console.log(huge); // 999999999999999999999999999999999999n

// BigInt может расти неограниченно
const massive = 10n ** 100n;
console.log(massive); // 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

// BigInt хранится в динамической памяти, не в фиксированном количестве битов

Как работает BigInt в памяти

BigInt не имеет фиксированного размера. JavaScript выделяет столько памяти, сколько нужно:

const num1 = 123n; // несколько байт
const num2 = 123456789012345678901234567890n; // больше байт
const num3 = 10n ** 10000n; // тысячи байт

// Память растет динамически по мере необходимости
console.log(num3.toString().length); // более 10000 цифр

Работа с очень большими числами: Decimal и произвольная точность

Decimal для чисел с плавающей точкой

Для высокой точности (например, в финансовых расчётах), используют библиотеки с произвольной точностью:

// С использованием Decimal.js
const Decimal = require('decimal.js');

const price = new Decimal('0.1');
const tax = new Decimal('0.2');
const total = price.plus(tax);
console.log(total.toString()); // "0.3" (без ошибок float)

// Может быть бесконечно большим числом
const huge = new Decimal('1e308');
const bigger = huge.times(huge);
console.log(bigger.toString()); // очень большое число

Решение исходной проблемы

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

// Проблема: число больше Number.MAX_VALUE (1.79e+308)
const problem = Number.MAX_VALUE * 2; // Infinity

// Решение 1: BigInt для целых чисел
const solution1 = 999999999999999999999999999999999999n;
console.log(solution1); // работает

// Решение 2: Decimal.js для чисел с точкой
const Decimal = require('decimal.js');
const solution2 = new Decimal('1.79e+400'); // очень большое число
console.log(solution2.toString()); // работает

// Решение 3: просто используй Infinity для представления неограниченности
if (value > Number.MAX_VALUE) {
  return Infinity; // это валидное представление
}

Структуры данных для работы с очень большими числами

Собственная реализация на основе массивов

Можно создать собственный класс для хранения больших чисел:

class BigNumber {
  constructor(digits = []) {
    this.digits = digits; // каждый элемент - цифра
  }
  
  static fromString(str) {
    const digits = str.split('').reverse().map(Number);
    return new BigNumber(digits);
  }
  
  toString() {
    return [...this.digits].reverse().join('');
  }
  
  add(other) {
    const result = [];
    let carry = 0;
    const maxLen = Math.max(this.digits.length, other.digits.length);
    
    for (let i = 0; i < maxLen || carry; i++) {
      const a = this.digits[i] || 0;
      const b = other.digits[i] || 0;
      const sum = a + b + carry;
      result.push(sum % 10);
      carry = Math.floor(sum / 10);
    }
    
    return new BigNumber(result);
  }
}

const big1 = BigNumber.fromString('999999999999999999999');
const big2 = BigNumber.fromString('111111111111111111111');
const sum = big1.add(big2);
console.log(sum.toString()); // 1111111111111111111110

Практические подходы

1. Если работаешь с целыми числами - используй BigInt

const factorial = (n) => n <= 1n ? 1n : n * factorial(n - 1n);
console.log(factorial(100n)); // огромное число

2. Если нужна точность - используй Decimal.js или similar

const Decimal = require('decimal.js');
Decimal.set({ precision: 1000 }); // максимум 1000 цифр
const pi = new Decimal('3.14159...');

3. Если нужно просто представить очень большое количество - используй Infinity

function clamp(value, max) {
  return Math.min(value, max === Infinity ? Infinity : max);
}

Заключение

JavaScript не ограничивает Infinity двоичным представлением - это встроенное значение стандарта IEEE 754. Если нужны числа больше Number.MAX_VALUE, используй BigInt для целых чисел (растет динамически в памяти) или библиотеки вроде Decimal.js для чисел с плавающей точкой. В обоих случаях программа выделяет ровно столько памяти, сколько требуется для хранения числа.