Числа и объект Math

Один тип `number` и плавающая точка (0,1 + 0,2), Number.EPSILON, безопасные целые и BigInt, Number/parseInt/parseFloat, NaN, ловушки округления, методы Math и случайные целые в диапазоне.

  • Начальный
  • 22 мин
  • 12 вопросов
  • Урок 4 из 39

В этом уроке ты узнаешь

  • Объяснять, почему 0.1 + 0.2 не равно 0,3, и правильно сравнивать дроби и считать деньги
  • Знать предел безопасных целых и при необходимости использовать BigInt
  • Преобразовывать строки через Number, parseInt, parseFloat и правильно проверять NaN
  • Округлять числа, пользоваться методами Math и получать случайное целое в диапазоне

Ты кладёшь в корзину интернет-магазина хлеб за 0,70 маната и пакет за 0,10 маната, а сайт пишет: «Итого: 0.7999999999999999 AZN». Ошибся программист или JavaScript не умеет считать? На самом деле компьютер хранит числа в двоичной системе, и это иногда даёт неожиданные результаты. В уроке «Операторы и приведение типов» ты мельком видел 0.1 + 0.2; в этом уроке подробно разберёшь, как хранятся числа, как работать с большими целыми, как правильно превращать строку в число, ловушки округления, объект Math и случайные числа.

Один тип для всех чисел

Тип numberОпределение

В JavaScript все целые и дробные числа имеют один тип number: 64-битное число с плавающей точкой (стандарт IEEE 754). 5, 5.0, -2.5 и 1e6 — один и тот же тип.

Поэтому 7 / 2 даёт 3,5, а не 3, как в некоторых других языках. Деление на ноль — не ошибка: результат — Infinity (бесконечность), а 0 / 0 даёт NaN («не число») — и это тоже тип number. Длинные числа можно писать с подчёркиваниями (1_000_000); 0x означает шестнадцатеричную запись, 0b — двоичную, а e — «умножить на степень 10»: 2e3 = 2000.

JavaScript
console.log(typeof 5, typeof 2.5, typeof NaN);
console.log(5 === 5.0, 7 / 2);
console.log(1 / 0, -1 / 0, 0 / 0);
console.log(1_000_000, 0xff, 0b1010, 2e3, 1.5e-3);
Ожидаемый результат
number number number
true 3.5
Infinity -Infinity NaN
1000000 255 10 2000 0.0015

Чтобы читать дальше, зарегистрируйся бесплатно

Остальные разделы урока, тест и заметки открываются с аккаунтом Educora. Регистрация занимает минуту, а прогресс сохраняется на всех твоих устройствах.

Плавающая точка: почему 0,1 + 0,2 не равно 0,3

В десятичной системе 1/3 нельзя записать точно: 0,333… тянется бесконечно, и где-то приходится обрезать. В двоичной системе та же беда с 0,1: это бесконечная двоичная дробь, поэтому в память записывается ближайшее значение — 0.1000000000000000055…. Обычно эта крошечная ошибка не видна при печати, но проявляется, когда складываешь или умножаешь несколько таких чисел.

JavaScript
console.log(0.7 + 0.1);
console.log(0.1 + 0.2 === 0.3);
console.log((0.1).toFixed(20));
console.log(1.6 * 3);
console.log(Math.floor(4.35 * 100), 4.35 * 100);
Ожидаемый результат
0.7999999999999999
false
0.10000000000000000555
4.800000000000001
434 434.99999999999994

Последняя строка особенно опасна: при переводе 4,35 маната в гяпики Math.floor дал 434 — один гяпик потерялся. Не сравнивай дробные числа через ===; проверяй, что их разность очень мала. Number.EPSILON — расстояние между 1 и следующим за ней значением number (около 2,2 · 10⁻¹⁶).

|a − b| < ε

Где

a, b
сравниваемые дробные числа
ε
допустимая погрешность: Number.EPSILON для чисел около 1, Number.EPSILON · max(|a|, |b|) для больших или малое число по смыслу задачи (0,005 для денег)

Два дробных числа считаются «равными», если модуль их разности меньше ε.

JavaScript
function nearlyEqual(a, b) {
  return Math.abs(a - b) < Number.EPSILON;
}
console.log(Number.EPSILON);
console.log(nearlyEqual(0.1 + 0.2, 0.3));
console.log(nearlyEqual(0.1 + 0.2, 0.31));

console.log(1000.1 + 1000.2);
console.log(Math.abs(1000.1 + 1000.2 - 2000.3) < Number.EPSILON);
console.log(Math.abs(1000.1 + 1000.2 - 2000.3) < Number.EPSILON * 2000.3);
Ожидаемый результат
2.220446049250313e-16
true
false
2000.3000000000002
false
true

У больших чисел расстояние между соседними значениями number тоже растёт, поэтому постоянный Number.EPSILON около 2000 уже слишком мал — допуск нужно умножать на величину чисел. А для денег надёжнее всего вообще обойтись без дробей.

Предел целых чисел и BigInt

number хранит целые числа точно лишь до определённого предела. Этот предел — Number.MAX_SAFE_INTEGER. Выше него между целыми появляются «дыры»: 2 ** 53 + 1 нельзя сохранить, и оно округляется до 2 ** 53. Number.isSafeInteger(n) проверяет, находится ли число ещё в безопасной зоне. Самое большое number — около 1,8 · 10³⁰⁸, всё, что больше, становится Infinity.

MAX_SAFE_INTEGER = 2⁵³ − 1 = 9007199254740991

Где

2⁵³
у number 53 двоичных разряда (бита) для значащей части

Для id, счётчиков и вычислений выше этого предела нужен BigInt.

JavaScript
console.log(Number.MAX_SAFE_INTEGER);
console.log(2 ** 53 === 2 ** 53 + 1);
console.log(9007199254740993);
console.log(Number.isSafeInteger(2 ** 53 - 1), Number.isSafeInteger(2 ** 53));
console.log(Number.MAX_VALUE, Number.MAX_VALUE * 2);
Ожидаемый результат
9007199254740991
true
9007199254740992
true false
1.7976931348623157e+308 Infinity

BigIntОпределение

Отдельный тип для целых чисел любого размера. В конце числа пишут n (10n) или вызывают BigInt('123'); typeof возвращает 'bigint'.

С BigInt операторы + - * ** % работают как обычно, а деление отбрасывает дробную часть (7n / 2n = 3n). BigInt и number нельзя смешивать в одном выражении — 10n + 1 выбрасывает TypeError, одно нужно явно преобразовать в другое. Сравнения работают (5n > 3). У BigInt нет дробей, методы Math его не принимают, а JSON.stringify его не знает, поэтому используй его только для действительно больших целых: 64-битных id из базы данных, факториалов, криптографии.

JavaScript
const big = 2n ** 64n;
console.log(big, typeof big);
console.log(9007199254740993n + 1n);
console.log(7n / 2n, 7n % 2n);

let f = 1n;
for (let i = 1n; i <= 25n; i++) f *= i;
console.log(f);

try {
  console.log(10n + 1);
} catch (error) {
  console.log(error.name);
}
console.log(10n + BigInt(1), Number(10n) + 1, 5n > 3);
Ожидаемый результат
18446744073709551616n bigint
9007199254740994n
3n 1n
15511210043330985984000000n
TypeError
11n 11 true

Из строки в число: Number, parseInt, parseFloat

Всё, что приходит из формы, URL или файла, — строка. Три способа превратить её в число работают по-разному. Number(text) (или унарный +text) требует, чтобы числом была вся строка, прощает пробелы по краям и превращает пустую строку в 0. parseInt(text, radix) читает цифры с начала строки и останавливается на первом «чужом» символе. parseFloat(text) делает то же для дробных чисел. Запятая для JavaScript не десятичный разделитель, поэтому '2,5', набранное пользователями az, ru и tr, нужно сначала исправить через replace(',', '.').

ВходNumber()parseInt()parseFloat()
'42'424242
'42px'NaN4242
'3.99'3.9933.99
'2,5'NaN22
''0NaNNaN
' 12 '121212
JavaScript
console.log(Number('42'), Number('42px'), Number(''), Number(' 12 '));
console.log(parseInt('42px'), parseInt('px42'), parseInt('3.99'));
console.log(parseFloat('3.14abc'), parseFloat('.5'), parseFloat('2,5'));
console.log(Number('2,5'), Number('2,5'.replace(',', '.')));
console.log(parseInt('ff', 16), parseInt('101', 2));
console.log(+'7' + 1, Number(null), Number(undefined), Number(true));
Ожидаемый результат
42 NaN 0 12
42 NaN 3
3.14 0.5 2
NaN 2.5
255 5
8 0 NaN 1

Если преобразование не удалось, получается NaN, а он ведёт себя странно: NaN не равен ничему, даже самому себе, поэтому x === NaN всегда false. Для проверки используй Number.isNaN(x). Старая глобальная isNaN(x) сначала превращает аргумент в число, поэтому isNaN('hello') даёт true, хотя это строка. Её родственники Number.isInteger (целое ли число?) и Number.isFinite (конечное ли число?) тоже не приводят типы.

JavaScript
const value = Number('hello');
console.log(value, value === NaN, Number.isNaN(value));
console.log(isNaN('hello'), Number.isNaN('hello'));
console.log(Number.isInteger(5), Number.isInteger(5.5), Number.isInteger('5'));
console.log(Number.isFinite(1 / 0), Number.isFinite(42), isFinite('42'));
Ожидаемый результат
NaN false true
true false
true false false
false true true

Округление: Math.round, toFixed и ловушки

Четыре функции превращают дробь в целое. Math.round даёт ближайшее целое, а половину округляет вверх (к +∞), поэтому Math.round(-2.5) равно −2, а не −3. Math.floor округляет вниз, Math.ceil — вверх, а Math.trunc просто отбрасывает дробную часть. Разница между floor и trunc видна на отрицательных числах:

JavaScript
console.log('x', 'round', 'floor', 'ceil', 'trunc');
for (const x of [2.5, 2.7, -2.5, -2.7]) {
  console.log(x, Math.round(x), Math.floor(x), Math.ceil(x), Math.trunc(x));
}
Ожидаемый результат
x round floor ceil trunc
2.5 3 2 3 2
2.7 3 2 3 2
-2.5 -2 -3 -2 -2
-2.7 -3 -3 -2 -2

Классический способ округлить до n знаков после запятой — умножить на 10ⁿ, округлить и разделить обратно. А toFixed(n) возвращает результат строкой — отлично для показа, но не для дальнейших вычислений.

round(x, n) = Math.round(x · 10ⁿ) / 10ⁿround(x, n) = Math.round(x · 10ⁿ) / 10ⁿ

Где

x
округляемое число
n
сколько знаков оставить после запятой

Осторожно: x · 10ⁿ само вычисляется с двоичной ошибкой — смотри пример ниже.

JavaScript
console.log((3.14159).toFixed(2), typeof (3.14159).toFixed(2));
console.log(Math.round(3.14159 * 100) / 100, (5).toFixed(2));

console.log((1.005).toFixed(2));
console.log((1.005).toFixed(20));
console.log(Math.round(1.005 * 100) / 100, 1.005 * 100);

function roundTo(x, digits) {
  return Number(Math.round(x + 'e' + digits) + 'e-' + digits);
}
console.log(roundTo(1.005, 2), roundTo(2.675, 2), roundTo(3.14159, 3));
const format = new Intl.NumberFormat('en-US', { maximumFractionDigits: 2 });
console.log(format.format(1.005), format.format(1234.5678));
Ожидаемый результат
3.14 string
3.14 5.00
1.00
1.00499999999999989342
1 100.49999999999999
1.01 2.68 3.142
1.01 1,234.57

1.005 в памяти на самом деле 1.00499…, поэтому и toFixed(2), и формула дали 1.00. Функция roundTo превращает число в строку вида '1.005e2': Number читает эту запись как десятичную и получает ровно 100,5. Intl.NumberFormat тоже округляет видимую десятичную запись и добавляет разделители тысяч; все его возможности — в уроке «Дата и время: Date и Intl».

Объект Math и случайные числа

Math — набор готовых математических функций: Math.max/Math.min (для массива — со spread: Math.max(...arr); пустой массив даёт -Infinity), Math.abs (модуль), Math.sign (знак), Math.sqrt и Math.cbrt (квадратный и кубический корень), Math.pow (то же делает **), Math.hypot (гипотенуза), Math.PI. Тригонометрические функции принимают радианы, а не градусы: 90° = π/2.

JavaScript
const scores = [72, 95, 88, 61];
console.log(Math.max(...scores), Math.min(...scores), Math.max());
console.log(Math.abs(-7), Math.sign(-7), Math.sqrt(144), Math.cbrt(27));
console.log(Math.pow(2, 10), 2 ** 10, Math.hypot(3, 4));
console.log(Math.PI.toFixed(5), Math.sin(Math.PI / 2), Math.sin(Math.PI));
Ожидаемый результат
95 61 -Infinity
7 -1 12 3
1024 1024 5
3.14159 1 1.2246467991473532e-16

Math.sin(Math.PI) дал не 0, а крошечное число — это тоже след плавающей точки, ведь Math.PI — не само π, а ближайшее к нему number. Math.random() возвращает случайную дробь из [0; 1): 0 может выпасть, 1 — никогда. Чтобы получить целое число из отрезка [min; max]:

randomInt = Math.floor(Math.random() · (max − min + 1)) + min

Где

max − min + 1
число возможных результатов (6 для кубика)
Math.floor
делит [0; 6) на целые 0, 1, …, 5 равными долями
+ min
сдвигает результат так, чтобы он начинался с min

Math.round(Math.random() * 6) неверно: даёт 7 результатов от 0 до 6, причём крайние выпадают вдвое реже.

JavaScript
function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

const rolls = Array.from({ length: 6000 }, () => randomInt(1, 6));
console.log(Math.min(...rolls), Math.max(...rolls));
console.log(rolls.every((r) => Number.isInteger(r) && r >= 1 && r <= 6));
console.log(new Set(rolls).size);

const wrong = Array.from({ length: 6000 }, () => Math.round(Math.random() * 6));
console.log(wrong.includes(0), Math.max(...wrong));
Ожидаемый результат
1 6
true
6
true 6
Кубики каждый раз выпадают по-разному, но на 6000 бросках результаты этих проверок практически всегда одинаковы.

Мини-проект: чек магазина. Цены приходят от пользователей строками (иногда с запятой), расчёт идёт в гяпиках, скидка 5 % округляется, а итоговая сумма показывается на трёх языках.

JavaScript
const cart = [
  { name: 'Bread', price: '0.70', qty: 2 },
  { name: 'Milk', price: '1,60', qty: 3 },
  { name: 'Tea', price: '4.35', qty: 1 },
];
const toQepik = (text) => Math.round(Number(text.replace(',', '.')) * 100);

let total = 0;
for (const item of cart) {
  const line = toQepik(item.price) * item.qty;
  total += line;
  console.log(item.name.padEnd(5), item.qty, 'x', item.price, '=', (line / 100).toFixed(2));
}
const discount = Math.round(total * 0.05);
const pay = total - discount;
console.log('Total:', (total / 100).toFixed(2), '| discount 5%:', (discount / 100).toFixed(2));
console.log(['en-US', 'ru-RU', 'tr-TR'].map((loc) =>
  new Intl.NumberFormat(loc, { style: 'currency', currency: 'AZN' }).format(pay / 100)).join(' | '));
Ожидаемый результат
Bread 2 x 0.70 = 1.40
Milk  3 x 1,60 = 4.80
Tea   1 x 4.35 = 4.35
Total: 10.55 | discount 5%: 0.53
AZN 10.02 | 10,02 AZN | AZN 10,02

Задание

sumPrices(texts) должна сложить цены, набранные пользователями: принимаются и запятая, и точка, пробелы по краям игнорируются, пустые и нечисловые строки пропускаются. Функция выводит две строки: сумму в манатах (toFixed(2)) и число пропущенных строк. Считай в гяпиках.

Задание · JavaScript
function sumPrices(texts) {
  let qepik = 0;
  let invalid = 0;
  // clean each text, convert it, skip the bad ones
  console.log((qepik / 100).toFixed(2));
  console.log(invalid);
}

sumPrices(['2,50', '19.99', ' 7 ', 'abc', '', '0.1', '0.2']);
Ожидаемый результат
29.79
2

Задание

splitBill(totalText, people) должна разделить счёт между друзьями с точностью до гяпика: части в сумме дают ровно итог, а оставшиеся гяпики по одному достаются первым. Верни части, оформленные через toFixed(2), одной строкой через пробел.

Задание · JavaScript
function splitBill(totalText, people) {
  // 1) total in qepik  2) base part and the remainder  3) build the string
}

console.log(splitBill('10.00', 3));
console.log(splitBill('25,5', 4));
console.log(splitBill('7', 2));
Ожидаемый результат
3.34 3.33 3.33
6.38 6.38 6.37 6.37
3.50 3.50

Запомни

  • Все числа — 64-битные number с плавающей точкой; дроби вроде 0,1 хранятся неточно.
  • Сравнивай дроби через |a − b| < ε, считай деньги целыми гяпиками и переводи через Math.round(x * 100).
  • Целые точны до 2⁵³ − 1; для больших — BigInt (10n), его нельзя смешивать с number.
  • Number читает всю строку, parseInt/parseFloat — её начало; NaN проверяй через Number.isNaN.
  • toFixed возвращает строку и может округлить числа вроде 1.005 вниз; для показа есть и Intl.NumberFormat.
  • Случайное целое на [min; max]: Math.floor(Math.random() * (max − min + 1)) + min; для паролей — crypto.
Заметил ошибку или неточность в уроке?

Проверь себя

Вопросов: 12. Каждый правильный ответ приносит XP.

Вопрос 1 / 12

Вопрос 1 / 12. Что выведет console.log(0.1 + 0.2 === 0.3)?