Числа: Number, Math, parseInt, parseFloat

JavaScript использует формат IEEE 754 double-precision (64-бит) для всех чисел; объект Number содержит константы и методы работы с числами, Math — математические функции, а parseInt/parseFloat парсят строки в числа.

Зачем нужно

Числа в JavaScript имеют нюансы: 0.1 + 0.2 !== 0.3 из-за плавающей точки, целые безопасны только до 2**53 - 1, а NaN не равен самому себе. Знание встроенных инструментов позволяет правильно округлять, парсить и сравнивать числа.

Где используется

  • Финансовые расчёты (округление, форматирование)
  • Парсинг ввода пользователя из форм
  • Математические операции в анимации, играх, графиках
  • Валидация числовых данных

Number — тип и объект

// Числовые литералы
const int   = 42;
const float = 3.14;
const hex   = 0xFF;     // 255
const bin   = 0b1010;   // 10
const oct   = 0o17;     // 15
const big   = 1_000_000; // разделитель _ (ES2021)
const sci   = 1.5e3;    // 1500

// Специальные значения
Infinity;   // бесконечность
-Infinity;
NaN;        // Not a Number

// Константы Number
Number.MAX_SAFE_INTEGER;  // 9007199254740991 (2**53 - 1)
Number.MIN_SAFE_INTEGER;  // -9007199254740991
Number.POSITIVE_INFINITY; // Infinity
Number.NEGATIVE_INFINITY; // -Infinity
Number.NaN;               // NaN
Number.EPSILON;           // 2.22e-16 (наименьшее различие)

Методы Number

const n = 3.14159;

// Округление для отображения
n.toFixed(2);        // '3.14' — строка!
n.toPrecision(4);    // '3.142' — строка
n.toExponential(2);  // '3.14e+0' — строка
n.toString(16);      // 'f' для 15, — шестнадцатеричное

// Проверки
Number.isInteger(3);     // true
Number.isInteger(3.5);   // false
Number.isFinite(Infinity); // false
Number.isFinite(42);      // true
Number.isNaN(NaN);         // true — надёжнее глобального isNaN
Number.isNaN('текст');     // false (глобальный isNaN('текст') === true — ловушка!)
Number.isSafeInteger(Number.MAX_SAFE_INTEGER); // true

// Преобразование в число
Number('42');      // 42
Number('3.14');    // 3.14
Number('');        // 0
Number(null);      // 0
Number(undefined); // NaN
Number('abc');     // NaN
+'42';             // 42 — унарный плюс

parseInt и parseFloat

// parseInt: парсит целое число из начала строки
parseInt('42px');      // 42 — игнорирует нечисловое после числа
parseInt('3.14');      // 3 — отбрасывает дробь
parseInt('0xFF', 16);  // 255 — второй аргумент — система счисления!
parseInt('10', 2);     // 2 — бинарное
parseInt('abc');       // NaN

// Второй аргумент radix — всегда указывай!
parseInt('010');       // 10 (в старых движках могло быть 8 — восьмеричное)
parseInt('010', 10);   // 10 — явно десятичное
parseInt('010', 8);    // 8 — восьмеричное

// parseFloat: парсит число с плавающей точкой
parseFloat('3.14rem'); // 3.14
parseFloat('1e3');     // 1000
parseFloat('abc');     // NaN

Math — математические функции

// Округление
Math.round(4.5);  // 5 — математическое округление
Math.ceil(4.1);   // 5 — вверх
Math.floor(4.9);  // 4 — вниз
Math.trunc(4.9);  // 4 — отбрасывает дробь (не round!)
Math.trunc(-4.9); // -4 (а не -5!)

// Абсолютное значение, знак
Math.abs(-5);    // 5
Math.sign(-5);   // -1
Math.sign(0);    // 0
Math.sign(5);    // 1

// Минимум, максимум
Math.min(1, 2, 3);  // 1
Math.max(1, 2, 3);  // 3
Math.min(...arr);   // минимум из массива через spread

// Степень, корень, логарифм
Math.pow(2, 10);   // 1024 — можно также 2**10
Math.sqrt(16);     // 4
Math.cbrt(27);     // 3 — кубический корень
Math.log(Math.E);  // 1 — натуральный логарифм
Math.log2(8);      // 3
Math.log10(1000);  // 3

// Константы
Math.PI;  // 3.14159...
Math.E;   // 2.71828...

// Случайное число [0, 1)
Math.random;

// Случайное целое в диапазоне [min, max]
function randomInt(min, max) {
  return Math.floor(Math.random * (max - min + 1)) + min;
}
randomInt(1, 6); // бросок кубика

Проблема плавающей точки

0.1 + 0.2;         // 0.30000000000000004 — не 0.3!
0.1 + 0.2 === 0.3; // false

// Решения:
// 1. Округлять при отображении
(0.1 + 0.2).toFixed(1); // '0.3'

// 2. Сравнивать с допустимой погрешностью
Math.abs((0.1 + 0.2) - 0.3) < Number.EPSILON; // true

// 3. Работать с целыми (копейки вместо рублей)
const price1 = 1000; // 10.00 рублей в копейках
const price2 = 2000; // 20.00 рублей в копейках
const total  = (price1 + price2) / 100; // 30 рублей — точно

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

1. parseInt без radix

parseInt('08'); // может быть 0 в старых движках (8 не является восьмеричной цифрой)
// Всегда:
parseInt('08', 10); // 8

2. NaN в условиях

const x = NaN;
if (x) {} // false, но NaN !== false

isNaN('abc');        // true — опасно: приводит к числу
Number.isNaN('abc'); // false — правильно: только реальный NaN

// Проверка числа:
function isNumber(value) {
  return typeof value === 'number' && !Number.isNaN(value) && Number.isFinite(value);
}

3. Потеря точности при больших числах

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true — потеря точности!
// Для больших чисел используй BigInt:
9007199254740991n + 1n; // 9007199254740992n — точно

Связанные темы

Ресурсы