Ты кладёшь в корзину интернет-магазина хлеб за 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.
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…. Обычно эта крошечная ошибка не видна при печати, но проявляется, когда складываешь или умножаешь несколько таких чисел.
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
- сравниваемые дробные числа
- ε
- допустимая погрешность:
Number.EPSILONдля чисел около 1,Number.EPSILON · max(|a|, |b|)для больших или малое число по смыслу задачи (0,005 для денег)
Два дробных числа считаются «равными», если модуль их разности меньше ε.
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.
Где
- 2⁵³
- у
number53 двоичных разряда (бита) для значащей части
Для id, счётчиков и вычислений выше этого предела нужен BigInt.
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 из базы данных, факториалов, криптографии.
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' | 42 | 42 | 42 |
'42px' | NaN | 42 | 42 |
'3.99' | 3.99 | 3 | 3.99 |
'2,5' | NaN | 2 | 2 |
'' | 0 | NaN | NaN |
' 12 ' | 12 | 12 | 12 |
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 (конечное ли число?) тоже не приводят типы.
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 видна на отрицательных числах:
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) возвращает результат строкой — отлично для показа, но не для дальнейших вычислений.
Где
- x
- округляемое число
- n
- сколько знаков оставить после запятой
Осторожно: x · 10ⁿ само вычисляется с двоичной ошибкой — смотри пример ниже.
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.
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]:
Где
- max − min + 1
- число возможных результатов (6 для кубика)
- Math.floor
- делит [0; 6) на целые 0, 1, …, 5 равными долями
- + min
- сдвигает результат так, чтобы он начинался с min
Math.round(Math.random() * 6) неверно: даёт 7 результатов от 0 до 6, причём крайние выпадают вдвое реже.
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
Мини-проект: чек магазина. Цены приходят от пользователей строками (иногда с запятой), расчёт идёт в гяпиках, скидка 5 % округляется, а итоговая сумма показывается на трёх языках.
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)) и число пропущенных строк. Считай в гяпиках.
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), одной строкой через пробел.
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.