Странные факты о PHP, которые всплывают даже в строгой типизации
PHP стал заметно строже, но внутри него по-прежнему живут механики, способные удивить даже опытного разработчика. Одни из них закреплены в документации, другие — побочный эффект работы с плавающей точкой, третьи прячутся в неявных сравнениях. Разберём три неочевидных факта и покажем, как вести себя с ними в современном коде.
Плавающая точка: когда 0.1 + 0.7 больше, чем кажется
Начнём с классики, которая никуда не делась из PHP 8.x. Возьмём на первый взгляд бесспорное выражение:
<?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
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
$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
$a = 'php';
$b = --$a;
echo $b; // phpТакже важен состав строки. Если в ней есть любой символ вне набора A-Za-z0-9, инкремент просто не сработает. Именно поэтому выражение ++($a_fact?) из примера не изменило строку — вопросительный знак не входит в допустимый диапазон.
На практике лучше не полагаться на автоматический инкремент строк и генерировать последовательности явно, особенно если нужна маска с ведущими нулями или сложный формат. Современный способ:
<?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
$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
$config = [
'count' => 1,
'references' => 0,
'ghosts' => 1,
];
var_dump(in_array('aurelio', $config)); // trueЗдесь строка 'aurelio' начинается не с цифры, поэтому при слабом сравнении с целым числом она приводится к 0. А 0 == 0 — это правда. В массиве есть нулевое значение, поэтому результат снова положительный.
Как защититься от ложных срабатываний
Решение — третий аргумент функции, включающий строгое сравнение:
<?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). Это включит строгое сравнение === вместо слабого ==, при котором строка может неявно приводиться к числу или булеву значению.