PHPTime

Странные факты о PHP, которые всплывают даже в строгой типизации

PHP стал заметно строже, но внутри него по-прежнему живут механики, способные удивить даже опытного разработчика. Одни из них закреплены в документации, другие — побочный эффект работы с плавающей точкой, третьи прячутся в неявных сравнениях. Разберём три неочевидных факта и покажем, как вести себя с ними в современном коде.

Плавающая точка: когда 0.1 + 0.7 больше, чем кажется

Начнём с классики, которая никуда не делась из PHP 8.x. Возьмём на первый взгляд бесспорное выражение:

PHP
<?php

echo (int) ((0.1 + 0.7) * 10);

Многие ожидают увидеть 8, но получают 7. Причина не в баге интерпретатора, а в том, как процессор хранит числа с плавающей точкой по стандарту IEEE 754. Десятичные дроби вроде 0.1 и 0.7 не имеют точного двоичного представления, поэтому результат их сложения — не 0.8, а 0.7999999999999999 с хвостом из девяток.

Дальше происходит каскадная потеря точности:

  • (0.1 + 0.7) сохраняется как 0.7999999999999999;
  • после умножения на 10 получаем 7.999999999999999;
  • приведение к int отсекает дробную часть без округления — в итоге 7.

Если бы мы выводили значение как float, PHP округлил бы его при печати и показал привычное 8. Но явное приведение типа срабатывает раньше, чем форматирование, поэтому ошибка становится видимой.

Правило простое: когда от результата зависит бизнес-логика — деньги, скидки, количество товара, — не кладите расчёты на IEEE 754.

Современный безопасный путь — использовать bcmath или decimal-расширение. Для конвертации валют и подобных операций строковые числа произвольной точности дают предсказуемый результат:

PHP
<?php

declare(strict_types=1);

$sum = bcadd('0.1', '0.7', 2);   // '0.80'
$total = bcmul($sum, '10', 2);   // '8.00'

echo (int) $total;               // 8

Внутри bcmath работает со строками, а не с float, поэтому проблемы двоичной аппроксимации просто не возникает. Если же производительность критична и допустима погрешность на уровне 14-го знака, обычный float всё ещё уместен для графики, статистики и приближённых вычислений.

Инкремент строк: магия, закреплённая в документации

С числами всё привычно: ++$a увеличивает значение на единицу. Но что произойдёт со строкой?

PHP
<?php

$a = 'fact_2';
echo ++$a; // fact_3

$a = '2nd_fact';
echo ++$a; // 2nd_facu

$a = 'a_fact';
echo ++$a; // a_facu

$a = 'a_fact?';
echo ++$a; // a_fact?

Поведение выглядит нелогичным, пока не разберёшь алгоритм. PHP наследует perl-совместимый инкремент строк: если строка состоит из алфавитно-цифровых ASCII-символов без пробелов и знаков препинания, интерпретатор увеличивает последний символ. Для строки 'Z' результатом будет 'AA', что отличается от C, где получился бы символ с ASCII-кодом на единицу больше.

Важный нюанс: магия работает только с инкрементом. Декремент строк в PHP не определён, и попытка его выполнить вернёт исходную строку без ошибок:

PHP
<?php

$a = 'php';
$b = --$a;

echo $b; // php

Также важен состав строки. Если в ней есть любой символ вне набора A-Za-z0-9, инкремент просто не сработает. Именно поэтому выражение ++($a_fact?) из примера не изменило строку — вопросительный знак не входит в допустимый диапазон.

На практике лучше не полагаться на автоматический инкремент строк и генерировать последовательности явно, особенно если нужна маска с ведущими нулями или сложный формат. Современный способ:

PHP
<?php

declare(strict_types=1);

function nextInvoiceNumber(int $lastNumber): string
{
    return sprintf('INV-%05d', $lastNumber + 1);
}

echo nextInvoiceNumber(120); // INV-00121

Гибкие сравнения: почему in_array находит то, чего нет

Типичный сбой, о котором догадываются не сразу: поиск строки в массиве с числами и булевыми значениями возвращает true.

PHP
<?php

$flags = [
    'isReady' => false,
    'isPHP' => true,
    'isStrange' => true,
];

var_dump(in_array('random text', $flags)); // true

Секрет в неявном приведении типов. По умолчанию in_array() использует слабое сравнение ==, а не строгое ===. При сравнении строки с булевым значением PHP сначала приводит оба операнда к bool. Любая непустая строка, кроме '0', приводится к true. Поэтому 'random text' == true даёт true, и функция честно сообщает, что элемент найден.

Аналогичная ситуация с числами:

PHP
<?php

$config = [
    'count' => 1,
    'references' => 0,
    'ghosts' => 1,
];

var_dump(in_array('aurelio', $config)); // true

Здесь строка 'aurelio' начинается не с цифры, поэтому при слабом сравнении с целым числом она приводится к 0. А 0 == 0 — это правда. В массиве есть нулевое значение, поэтому результат снова положительный.

Как защититься от ложных срабатываний

Решение — третий аргумент функции, включающий строгое сравнение:

PHP
<?php

declare(strict_types=1);

$config = [
    'count' => 1,
    'references' => 0,
    'ghosts' => 1,
];

var_dump(in_array('aurelio', $config, true)); // false

То же относится к функциям-родственникам: array_search() имеет третий параметр для строгого сравнения, а вот array_key_exists() использует строгую проверку ключей всегда, поэтому с ключами такой проблемы не возникает.

Вот таблица сравнений, которые легко дают неожиданный результат при слабом сопоставлении:

Левый операнд Правый операнд Результат ==
'' false true
'0' false true
null array() true
'random text' true true
'random text' 0 true

Если включить строгую типизацию declare(strict_types=1), она защищает только вызовы функций и методы от передачи аргументов неправильного типа. Внутри самого кода PHP по-прежнему позволяет слабое сравнение через ==. Поэтому привычку использовать строгие операторы стоит вырабатывать отдельно.

Почему это до сих пор существует

Все три факта — не случайные ошибки, а результат осознанных решений, совместимых с PHP прошлых лет. Плавающая точка одинакова для всех языков с IEEE 754: Python, JavaScript и C++ дадут те же сюрпризы. Инкремент строк остался от Perl и не убран ради обратной совместимости. Слабое сравнение — фундамент нетипизированной природы PHP, который никуда не исчезнет, потому что на нём построено слишком много легаси-кода.

Разница с современным PHP лишь в том, что теперь у нас есть инструменты для контроля. Строгая типизация, явные сравнения и математические расширения позволяют писать предсказуемый код, не полагаясь на неявные преобразования.

Практический чек-лист

  • Для точных вычислений используйте bcmath или decimal, а не float.
  • Перед приведением float к int округляйте значение явно: round(), floor() или ceil().
  • Не полагайтесь на автоинкремент строк: генерируйте последовательности через sprintf() и явное числовое значение.
  • Используйте третий параметр в in_array() и array_search(), если тип данных в массиве не гарантирован.
  • Помните, что declare(strict_types=1) не защищает от == — выбирайте === по умолчанию.
  • Перед сравнением строк с числами или булевыми значениями приводите типы явно.

Частые вопросы

Почему (int) ((0.1 + 0.7) * 10) возвращает 7, а не 8?

Числа с плавающей точкой хранятся в двоичном виде, и десятичные дроби 0.1 и 0.7 не имеют точного двоичного представления. Сумма получается как 0.7999999999999999, после умножения на 10 — 7.999999999999999. Приведение к int отсекает дробную часть, поэтому результат равен 7.

Можно ли исправить неточность float с помощью strict_types?

Нет. declare(strict_types=1) проверяет типы при вызове функций и методов, но не меняет арифметику IEEE 754. Для точных вычислений нужно использовать bcmath или decimal, работающие со строками и произвольной точностью.

Почему инкремент строки 'a_fact' меняет последнюю букву на u?

PHP наследует поведение Perl: если строка состоит только из букв и цифр ASCII, оператор ++ увеличивает последний символ по алфавиту. Декремент строк не определён, а наличие знаков препинания отменяет магию.

Как заставить in_array не находить несуществующую строку в массиве с числами?

Нужно передать третий аргумент true: in_array('строка', $array, true). Это включит строгое сравнение === вместо слабого ==, при котором строка может неявно приводиться к числу или булеву значению.

Справка по теме

Ещё в разделе «Архитектура и практика»

Эффективный рефакторинг PHP-кода

Практическое руководство по рефакторингу в PHP 8.3–8.5. Как зафиксировать поведение тестами, усилить типизацию, разделить обязанности и удалить мёртвый код.

7 мин

Декаплинг и фреймворки в PHP: как перестать зависеть от чужих обновлений

Как отделить бизнес-логику от фреймворка в современных PHP-проектах. Интерфейсы, DTO, адаптеры, DI-контейнеры и стратегии миграции без остановки разработки.

7 мин

Как задать вопрос по PHP, чтобы получить ответ

Как задать вопрос по PHP: соберите минимальный воспроизводимый пример, укажите версии и условия запуска, приложите текст ошибки и выберите площадку.

7 мин

Учимся по видеозаписям конференций PHP Frameworks Day: практический гид

Как системно учиться по записям выступлений с PHP-конференций: выбирать доклады, конспектировать код, внедрять практики в проект.

5 мин