Есть ли максимальное значение для переменной типа number?

Максимальное значение типа number в JavaScript

Да, существует максимальное значение для типа number в JavaScript. Это важное знание, потому что многие разработчики не осознают ограничений числовых типов и встречаются с неожиданными ошибками при работе с большими числами.

Стандарт IEEE 754

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

• 1 бит для знака (плюс или минус)
• 11 бит для экспоненты
• 52 бита для мантиссы (дробная часть)

Максимальные значения

Number.MAX_VALUE
// 1.7976931348623157e+308
// Это примерно 1.8 × 10^308

Number.MAX_SAFE_INTEGER
// 9007199254740991
// Это 2^53 - 1

Number.MIN_VALUE
// 5e-324
// Самое маленькое положительное число

Number.MIN_SAFE_INTEGER
// -9007199254740991
// Это -(2^53 - 1)

Важное различие: MAX_VALUE vs MAX_SAFE_INTEGER

MAX_VALUE — это максимальное число, которое JavaScript может представить вообще:

let huge = Number.MAX_VALUE;
console.log(huge);
// 1.7976931348623157e+308

let hugeMore = huge + 1;
console.log(hugeMore);
// 1.7976931348623157e+308 (не изменилось!)

MAX_SAFE_INTEGER — это максимальное число, до которого вы можете работать безопасно, то есть без потери точности при математических операциях:

let safe = Number.MAX_SAFE_INTEGER;
console.log(safe);
// 9007199254740991

let safeMore = safe + 1;
console.log(safeMore);
// 9007199254740992
// Но это неправильно! safe + 1 должно быть 9007199254740992

let safeMore2 = safe + 2;
console.log(safeMore2);
// 9007199254740992 (снова то же самое!)
// Мы потеряли точность

console.log(Number.isSafeInteger(safe + 1));
// false

Проблема: потеря точности

После MAX_SAFE_INTEGER JavaScript не может точно представить каждое целое число:

const a = 9007199254740992;
const b = 9007199254740993;

console.log(a === b);
// true (!)
// Это ошибка! Они не должны быть равны

Это происходит потому, что мантисса имеет только 52 бита, и после определённой точки один бит представляет прыжок в 2, а не в 1.

Бесконечность

Что происходит, если превысить MAX_VALUE?

let infinity = Number.MAX_VALUE * 2;
console.log(infinity);
// Infinity

let negativeInfinity = -Number.MAX_VALUE * 2;
console.log(negativeInfinity);
// -Infinity

console.log(typeof Infinity);
// "number" (да, Infinity это число в JavaScript!)

console.log(Infinity === Infinity);
// true

console.log(Infinity + 1);
// Infinity

console.log(Infinity - Infinity);
// NaN (Not-a-Number)

NaN (Not-a-Number)

Особое значение для операций, которые дают недействительный результат:

const result = 0 / 0;
console.log(result);
// NaN

console.log(typeof NaN);
// "number" (да, NaN тоже число!)

console.log(NaN === NaN);
// false (специальное поведение)

console.log(Number.isNaN(NaN));
// true (правильный способ проверить NaN)

Решение для больших чисел: BigInt

Для работы с числами больше MAX_SAFE_INTEGER используй BigInt:

const big1 = BigInt(9007199254740992);
const big2 = BigInt(9007199254740993);

console.log(big1 === big2);
// false (теперь правильно!)

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

// Но не все операции доступны для BigInt
const result = huge + 1n;
console.log(result);
// 12345678901234567890123456790n

Важно: нельзя смешивать number и BigInt:

const num = 10;
const big = BigInt(10);

console.log(num + big);
// TypeError: Cannot mix BigInt and other types

Практические примеры ошибок

// Проблема: ID пользователя из API может быть больше безопасного
const userId = 9007199254740993; // потеря точности

// Решение:
const userId = BigInt("9007199254740993");
// Или строка: "9007199254740993"

// Проблема: финансовые расчёты
const price = 0.1 + 0.2;
console.log(price);
// 0.30000000000000004 (потеря точности с плавающей запятой)

// Решение: работай в центах (целые числа)
const priceInCents = 10 + 20; // 30 центов

Проверка безопасного диапазона

function isSafeNumber(num) {
  return Number.isSafeInteger(num) &&
         num >= Number.MIN_SAFE_INTEGER &&
         num <= Number.MAX_SAFE_INTEGER;
}

console.log(isSafeNumber(100));
// true

console.log(isSafeNumber(9007199254740992));
// false

Вывод

Для фронтенд разработчика важно помнить:

• Максимальное число: Number.MAX_VALUE (1.8e308)
• Максимальное безопасное целое число: Number.MAX_SAFE_INTEGER (2^53 - 1 = примерно 9 квадриллионов)
• Для работы с ID и больших чисел используй BigInt или строки
• Будь осторожен с финансовыми расчётами (используй целые числа в центах/копейках)