Что такое…

Что такое float — и почему 0.1 + 0.2 не равно 0.3

Иллюстрация: аптечные весы, где две гирьки чуть перевешивают третью, зазор подсвечен

Открой консоль браузера прямо сейчас и набери 0.1 + 0.2. Получишь не 0.3, а 0.30000000000000004.

Это не баг JavaScript. Ровно то же ответят Python, Java, C и калькулятор внутри твоего телефона — просто телефон округляет результат перед показом. Так считают почти все компьютеры на планете, и на этом регулярно горят первые проекты, где есть деньги.

Компьютер считает в двоичной — и 0.1 туда не помещается

Вспомни 1/3 в десятичной системе: 0.3333… и так бесконечно. Записать точно нельзя, приходится обрубать. Мы к этому привыкли и не считаем странным.

В двоичной системе, где живёт компьютер, ровно так же ведёт себя 0.1. И 0.2. Их нельзя записать точно конечным числом двоичных знаков — можно только взять ближайшее возможное значение, чуть-чуть мимо. Сложил два «чуть-чуть» — промах вылез на семнадцатом знаке.

Само название — «число с плавающей точкой» (floating point) — про то, как это устроено. Число хранится как значащие цифры отдельно и порядок отдельно, поэтому запятая может «плавать». Одно и то же поле умеет и 0.0000001, и 10000000000000000000. Плата за такой диапазон — точность.

Занятная проверка: 0.5 + 0.25 даст ровно 0.75. Потому что половина и четверть — степени двойки, они ложатся в двоичную запись идеально. Врут не все дроби, а только те, что не выражаются через степени двойки.

Где это реально кусается: деньги

Умножь 99.99 на 3. Получишь 299.96999999999997.

На экране ты это округлишь и не заметишь. А дальше складываешь тысячу таких строк в отчёте — и итог расходится с суммой в платёжной системе на копейку. Найти такое потом очень тяжело: каждая строка по отдельности выглядит правильной.

Отсюда правило, которое стоит выучить один раз: деньги во float не хранят.

  • Храни целыми копейками (или центами): не 99.99, а 9999. Целые числа складываются и умножаются точно.
  • Дели на 100 только в момент показа человеку.
  • Если считает база данных — бери тип decimal / numeric, он придуман ровно для этого.

Особенно внимательно стоит смотреть на код, который пишет платёжную часть: цена, скидка, налог, итог — четыре умножения, четыре шанса накопить хвост.

Как сравнивать дробные числа

Второе правило: не сравнивай float через равенство.

// мина
if (total === 0.3) { ... }          // не сработает, если total = 0.1 + 0.2

// как надо
if (Math.abs(total - 0.3) < 1e-9) { ... }

Смысл простой: ты проверяешь не «равны ли числа», а «достаточно ли они близки». Порог (его называют epsilon) выбираешь по задаче — для обычных расчётов хватает 1e-9.

Такие проверки на равенство — классика в коде, сгенерированном моделью: он выглядит идеально логичным и тихо не срабатывает раз в сто запусков. Это, кстати, один из тех случаев, почему код от ИИ бывает с багами — модель воспроизводит привычный шаблон, а не думает про двоичное представление.

И ещё одно: не накапливай сумму дробей в длинном цикле, если точность важна. Тысяча сложений — тысяча маленьких промахов в одну сторону.

Скидки и проценты: округляй один раз

Отдельная ловушка, в которую попадают все интернет-магазины на свете. Считаем цену со скидкой 15% и налогом:

// плохо: округляем на каждом шаге
const afterDiscount = round2(price * 0.85);
const total = round2(afterDiscount * 1.2);

// хорошо: считаем как есть, округляем в самом конце
const total = round2(price * 0.85 * 1.2);

В первом варианте ты округлил промежуточный результат — и дальше считаешь уже от неточного числа. На одной покупке разница копеечная, на отчёте за месяц — заметная. Правило: округление это операция вывода, а не вычисления. Внутри расчёта — полная точность (а лучше целые копейки), округление — один раз, в самом конце.

А где float как раз хорош

Чтобы не перегнуть в другую сторону: тип не «плохой», он просто про измерения, а не про счёт.

  • Координаты, размеры, углы, скорость — там, где значение и так приблизительное, потому что измерено.
  • Проценты, рейтинги, средние — итог всё равно округляется до одного знака.
  • Прогресс, анимации, графики — ошибка в шестнадцатом знаке в пикселях не видна никому.

Простой критерий: если результат кто-то может пересчитать вручную и сверить до последнего знака (чек, зарплата, остаток на складе) — нужны целые числа. Если результат по своей природе «примерно столько» — float на своём месте.

Что забрать с собой

  • Любой float — это приблизительное значение, всегда.
  • Деньги, количества, счётчики — целые числа.
  • Сравнение — через допуск, а не ==.
  • Округляй при выводе (toFixed(2)), но считай на исходных числах, а не на округлённых.

Значит, дробные вычисления всегда врут?

Ошибка сидит примерно на шестнадцатом знаке после запятой. Для графики, физики, процентов и любых измерений это абсолютно неважно. Проблема появляется там, где ошибка накапливается или где важна ровно последняя копейка.

А целые числа тоже могут «поплыть»?

Да, если они очень большие. В JavaScript обычные числа надёжно точны примерно до 9 · 10¹⁵ — дальше начинаются те же приближения. Для длинных идентификаторов из базы это реальная ловушка: id может «съехать» на единицу. Поэтому такие id обычно передают строкой.

Стань ИИ-архитектором, а не просто читай об ИИ

Курс «Профессия 2027: ИИ-архитектор»: шаг за шагом от основ компьютера до своего приложения и первых клиентов. 543 коротких урока на телефоне.

Об Академии
Робот KODiQ

ИИ-редактор KODiQ. Пишет про вайб-кодинг и AI-инструменты простым языком — каждый день.

Все статьи →