Перейти к основному содержимому

Управляющие конструкции и циклы в PHP

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ
Разработчику Архитектору

Перед чтением: Операторы — общие понятия оператора, операнда, приоритетов и типов операций без привязки к языку.

Сначала: Циклы в коде — общая идея повторений, виды циклов и типичные ошибки без привязки к синтаксису языка.

PHP — ветвление и циклы​

Условия — if / elseif / else, с PHP 8 — match. Циклы — for, foreach, while, do-while; для массивов обычно foreach, а не индексный for.

В условиях PHP приводит значения к bool — ложными считаются 0, '', [], null, false; остальное — истина. Это удобно в шаблонах, но легко спутать 0 и '0' при строгом сравнении — см. === ниже в статье.

Эта тема напрямую связана с функциями и замыканиями: цикл часто живет внутри функции, а условия управляют ветками обработки данных. Для ветвления в обработчиках форм полезно дополнительно посмотреть работу с данными со страницы.

Условные конструкции​

Play ITЗагрузка интерактивного демо…

Конструкция if​

Конструкция if позволяет выполнять блок кода только при истинности заданного условия. Алгоритм работы строится на проверке логического выражения, которое может принимать значение истинно или ложно.

Синтаксис конструкции состоит из ключевого слова if, за которым следует условие в круглых скобках, а затем блок кода в фигурных скобках. Если условие возвращает значение истинно, код внутри блока выполняется. Если условие ложно, блок пропускается, и выполнение продолжается с инструкции, следующей за всей конструкцией.

if (<условие>) {
    // выполняется, если условие истинно
} elseif (<другое_условие>) {
    // выполняется, если предыдущее ложно, а это — истинно
} else {
    // выполняется, если все условия ложны
}

Разбор:

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

Для обработки нескольких взаимозависимых ситуаций используется конструкция с ветвлением. Ключевое слово elseif добавляет возможность проверить альтернативное условие, если предыдущее оказалось ложным. Ключевое слово else охватывает все случаи, когда ни одно из предыдущих условий не выполнилось.

<?php
$temperature = 22;

if ($temperature > 30) {
    echo "Жарко";
} elseif ($temperature > 20) {
    echo "Комфортно";
} elseif ($temperature > 10) {
    echo "Прохладно";
} else {
    echo "Холодно";
}

Разбор:

  • Значение $temperature последовательно проверяется по порогам: от самого высокого к более низким.
  • При 22 условие > 30 ложно, а > 20 истинно, поэтому выводится Комфортно.
  • После срабатывания одной ветки остальные уже не исполняются.
  • Это типичный пример "приоритетных диапазонов", где порядок условий определяет результат.
  • В реальном коде такой блок часто оборачивают в функцию, возвращающую категорию.

В данном случае переменная хранит значение 22. Условие проверяет, больше ли это число 30. Результат проверки — ложь, поэтому текст "Жарко" не выводится на экран.

Конструкция поддерживает неограниченное количество веток elseif. Проверка условий происходит строго сверху вниз. Первое истинное условие определяет выполняемый блок; остальные игнорируются.

При работе с данными, поступающими извне, такими как параметры запроса $_GET или данные формы, необходимо строго контролировать их тип и содержание. Неявное приведение типов в PHP может привести к неожиданным результатам и уязвимостям безопасности.

Функция filter_input предназначена для безопасного получения и фильтрации входных данных. Она принимает имя типа источника данных, имя переменной и константу фильтра. В примере используется фильтр FILTER_VALIDATE_INT для проверки того, является ли введенное значение целым числом.

$id = filter_input(INPUT_GET, 'id', FILTER_VALIDATE_INT);

Разбор:

  • filter_input безопасно читает параметр из $_GET и сразу валидирует его тип.
  • FILTER_VALIDATE_INT гарантирует, что значение соответствует целому числу.
  • При ошибке валидации возвращается false, что удобно для явной проверки.
  • Такой подход надежнее ручного приведения строк к числам.
  • Особенно полезно на границе приложения, где данные приходят от пользователя.

Если параметр id отсутствует или не является числом, функция вернет false. Если параметр существует и корректен, она вернет само число.

Проверка результата должна включать два аспекта: наличие значения и его соответствие требованиям. Использование оператора строгости !== гарантирует, что false не будет автоматически преобразовано в 0 или другую допустимую величину.

if ($id !== false && $id > 0) {
    loadItem($id);
}

Разбор:

  • !== false — строгая проверка успешной валидации, без неявного приведения типов.
  • Условие $id > 0 вводит бизнес-ограничение на допустимый диапазон идентификатора.
  • Только при выполнении двух условий вызывается loadItem($id).
  • Паттерн уменьшает риск некорректных запросов к БД.
  • Логика хорошо читается как "guard before action".

Условие $id !== false подтверждает, что данные были успешно получены и имеют правильный тип. Условие $id > 0 гарантирует, что идентификатор положительный, так как отрицательные или нулевые значения часто недопустимы для поиска записи в базе данных. Только при одновременном выполнении обоих условий вызывается функция загрузки элемента.

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

Альтернативный синтаксис шаблонов​

В HTML-шаблонах допустим альтернативный синтаксис, повышающий читаемость:

<?php if (<условие>): ?>
    <!-- HTML -->
<?php elseif (<условие>): ?>
    <!-- другой HTML -->
<?php else: ?>
    <!-- резервный HTML -->
<?php endif; ?>
<?php if ($isLoggedIn): ?>
    <div>Привет, <?= htmlspecialchars($user) ?>!</div>
<?php else: ?>
    <form method="post" action="/login">
        <input name="user">
        <button>Войти</button>
    </form>
<?php endif; ?>

Разбор:

  • Блок рендерит разный HTML в зависимости от состояния авторизации пользователя.
  • В ветке приветствия используется htmlspecialchars($user), что защищает от XSS при выводе имени.
  • В альтернативной ветке отображается форма входа с отправкой POST на /login.
  • Это серверный conditional rendering: интерфейс формируется до отправки в браузер.
  • Альтернативный синтаксис if: ... endif; делает смешанный HTML/PHP-шаблон визуально чище.

Этот стиль применяется только в смешанных файлах (HTML + PHP). В чистом коде используется фигурный синтаксис.

Конструкция switch​

Конструкция switch сравнивает выражение с набором значений и выполняет соответствующий блок кода.

Алгоритм работы строится на последовательном переборе случаев до тех пор, пока не будет найдено подходящее значение или не будет достигнут конец конструкции.

Синтаксис конструкции начинается с ключевого слова switch, за которым следует выражение в круглых скобках. Далее следуют блоки case, каждый из которых содержит одно из возможных значений для сравнения. После каждого значения ставит двоеточие, а затем идет блок кода, который должен выполниться при совпадении. Завершается конструкция блоком default, который выполняется, если ни один из предыдущих случаев не подошел.

switch (<выражение>) {
    case <значение1>:
        // действия
        break;
    case <значение2>:
        // действия
        break;
    default:
        // действия по умолчанию
}

Код ITЗагрузка примера кода…

Разбор:

  • switch сравнивает $status с дискретными кодами 200/404/500.
  • При совпадении 404 выполняется соответствующий case и выводится текст об ошибке страницы.
  • break останавливает выполнение, не давая перейти в следующие ветки.
  • default покрывает все непрописанные значения.
  • Конструкция удобна для статусов, режимов и кодов ошибок.

В данном примере переменная $status хранит число 404. Система сравнивает это значение с каждым из условий case. Первое условие (200) не совпадает. Второе условие (404) совпадает. Скрипт выполняет код внутри этого блока, выводя текст "Страница не найдена". Затем выполнение переходит к инструкции, следующей за всей конструкцией switch.

Ключевой особенностью конструкции switch является использование оператора слабого сравнения (==). Это означает, что PHP автоматически приводит типы данных к общему виду перед проверкой равенства. Строка '2' считается равной числу 2. Число true равно 1, а false равно 0. Такое поведение позволяет упростить запись кода, но требует внимательности при работе со смешанными типами данных.

Каждая ветка case должна завершаться инструкцией break. Эта команда принудительно прерывает выполнение цикла switch и передает управление дальше по потоку программы. Если инструкция break отсутствует, происходит так называемое проваливание (fall-through). Выполнение продолжается в следующем блоке case, независимо от того, совпадает ли его значение с исходным выражением.

Особенности switch:

  • Использует слабое сравнение (==). Это означает, что '2' == 2 — true.
  • Требует явного указания break в конце каждой ветки. Без него выполнение "проваливается" в следующую ветку.
  • Поддерживает ветку default для обработки всех остальных случаев.
  • Может содержать составные инструкции — переменные, циклы, вызовы функций.

Пример проваливания:

switch ($role) {
    case 'admin':
        grantFullAccess();
        // нет break — продолжаем
    case 'editor':
        grantEditAccess();
        break;
    default:
        grantReadAccess();
}

При значении роли 'admin' система сначала выполняет функцию предоставления полного доступа. Поскольку после этого блока нет команды break, выполнение не останавливается, а переходит к следующему случаю case 'editor'. Там вызывается функция предоставления прав редактора. Только после нее встречается break, который завершает работу конструкции. В результате пользователь получает права администратора и редактора одновременно.

Такой паттерн иногда используется намеренно для объединения логики нескольких случаев. Например, если права администратора должны включать в себя все права редактора, можно опустить break после случая администратора. Однако этот подход снижает читаемость кода и повышает риск ошибок. При использовании такого метода необходимо оставлять подробные комментарии, объясняющие причину отсутствия инструкции break.

Ветка default служит запасным вариантом обработки. Она выполняется, если ни одно из условий case не дало положительного результата. Эта ветка не обязательно должна быть последней, но стандартная практика предполагает ее размещение в конце конструкции. Если default стоит перед другими случаями, она также будет работать как точка входа, если совпадение не найдено, но порядок проверки остается строгим сверху вниз.

Внутри блоков case разрешается размещать любые допустимые инструкции PHP. Это могут быть присваивания переменных, циклы, вызовы функций, условные операторы if и другие конструкции. Главное требование — корректное завершение каждой ветки командой break (если проваливание не запланировано) или явное завершение работы конструкции.

Пример использования составной инструкции:

Код ITЗагрузка примера кода…

Здесь каждый случай содержит несколько строк кода, выполняющих комплексные операции. В случае создания записи проверяется результат функции createRecord, и только при успехе отправляется уведомление. Такой подход позволяет инкапсулировать сложную логику внутри одной структуры выбора, делая код более организованным по сравнению с использованием множества вложенных операторов if-elseif.

Конструкция switch эффективна при наличии большого количества фиксированных значений для проверки одного выражения. Она делает код более лаконичным и понятным, когда количество условий превышает три-четыре варианта. Для проверки диапазонов значений или сложных логических выражений конструкция if часто подходит лучше, так как switch работает только с точным совпадением (или слабым приведением типов).

Использование switch рекомендуется, когда нужно обработать множество дискретных состояний объекта, таких как HTTP-статусы, типы пользователей, режимы работы системы или коды ошибок. Структура обеспечивает четкую визуальную иерархию и упрощает навигацию по коду при большом количестве вариантов развития событий.

Оператор match (PHP 8.0+)​

Оператор match — функциональная альтернатива switch. Он всегда возвращает значение, использует строгое сравнение (===) и не допускает проваливания.

$<результат> = match (<выражение>) {
    <значение1> => <результат1>,
    <значение2>, <значение3> => <результат2>,
    default => <резервный_результат>
};

Код ITЗагрузка примера кода…

Разбор:

  • match присваивает результат прямо в переменную, поэтому хорошо подходит для маппинга кодов в метки.
  • В отличие от switch, здесь строгое сравнение и нет проваливания между ветками.
  • Ветка 200, 201, 204 => 'Успех' показывает группировку нескольких значений в один результат.
  • default закрывает необработанные случаи и делает выражение полным.
  • Формат особенно удобен для преобразования входных кодов в бизнес-категории.

Преимущества match:

  • Компактность и безопасность.
  • Возможность использования внутри выражений.
  • Гарантированное покрытие всех случаев (иначе — исключение UnhandledMatchError).

Ограничения:

  • Каждая ветка — одно выражение, без составных инструкций.
  • Не подходит для побочных эффектов (например, логирования).

Логические и тернарные операторы​

Тернарный оператор​

Тернарный оператор позволяет компактно записать простое условное присваивание.

$<результат> = <условие> ? <значение_если_истина> : <значение_если_ложь>;
$status = ($age >= 18) ? 'взрослый' : 'несовершеннолетний';

Разбор:

  • Тернарный оператор выполняет компактное условное присваивание в одну строку.
  • Если $age >= 18, переменная получает взрослый, иначе несовершеннолетний.
  • Хорошо подходит для простых бинарных решений без побочных эффектов.
  • Для сложных веток с несколькими действиями лучше использовать обычный if.
  • Важно сохранять читаемость и не строить вложенные тернарные цепочки.

Сокращённая форма (Elvis operator):

$<результат> = <выражение> ?: <значение_по_умолчанию>;
$username = $_GET['user'] ?: 'Гость';

Разбор:

  • Сокращенный тернарный оператор ?: проверяет "истинность" левой части.
  • Если $_GET['user'] пустой/ложный, подставляется значение по умолчанию Гость.
  • Нюанс: '0', 0 и '' тоже считаются ложными и будут заменены.
  • Для случаев, где важно отличать null от валидного нуля, лучше применять ??.
  • Такой паттерн часто используют для fallback-значений в UI.

Здесь $username получит значение $_GET['user'], если оно истинно, иначе — 'Гость'.

Оператор null coalescing (??)​

Оператор ?? проверяет значение на строгое равенство null.

$<результат> = $<возможно_null> ?? <значение_по_умолчанию>;
$page = $_GET['page'] ?? 1;

Разбор:

  • ?? возвращает правую часть только когда левое значение отсутствует или равно null.
  • Значения 0 и '' не подменяются, что отличает оператор от ?:.
  • Это стандартный шаблон для дефолтной страницы пагинации.
  • После присваивания обычно добавляют проверку диапазона (>= 1).
  • Код короткий и безопасный для чтения необязательных параметров запроса.

Если $_GET['page'] равно null, будет использовано 1. Значения 0, '0', '' считаются валидными и не заменяются.

Цепочка:

$value = $a ?? $b ?? $c ?? 'default';

Null coalescing assignment (??=)​

Начиная с PHP 7.4:

$config['timeout'] ??= 30;

Разбор:

  • Оператор ??= инициализирует ключ только при отсутствии значения или null.
  • Он эквивалентен длинной форме с ??, но делает намерение "задать по умолчанию" очевидным.
  • Подход уменьшает шаблонный код в конфигурационных блоках.
  • При уже установленном значении timeout присваивания не происходит.
  • Удобен для построения гибких настроек с override-механикой.

Эквивалентно:

$config['timeout'] = $config['timeout'] ?? 30;

Интерактивное демо — пошаговый цикл на примере JavaScript (for, while). В PHP синтаксис другой, но порядок шагов тот же. Обобщённо: циклы в коде.

Play ITЗагрузка интерактивного демо…

Циклические конструкции​

Цикл for​

Цикл for используется, когда известно количество итераций или требуется числовая индексация.

Цикл for представляет собой механизм повторения выполнения блока кода, когда заранее известно количество необходимых итераций или требуется последовательная нумерация шагов. Этот инструмент идеально подходит для работы с массивами по индексу, перебора числовых диапазонов и реализации алгоритмов, зависящих от счетчика. Алгоритм работы строится на трех четко определенных этапах, которые выполняются в строгой последовательности до тех пор, пока условие истинно.

Синтаксис конструкции состоит из ключевого слова for, за которым следуют три выражения, разделенные точкой с запятой, и заключенные в круглые скобки. Затем идет блок кода в фигурных скобках, который будет выполняться многократно.

for ($<счётчик> = <начало>; $<счётчик> < <конец>; $<счётчик>++) {
    // тело цикла
}

Первое выражение — это инициализация. Оно выполняется один раз перед началом первого прохода цикла. В этой части обычно объявляется переменная-счетчик и присваивается ей начальное значение. Если переменная уже существует, инициализация может быть опущена или просто выполнена как присваивание.

Второе выражение — это условие завершения. Оно проверяется перед каждой итерацией. Система вычисляет логическое значение этого условия. Если результат истинен, выполняется тело цикла. Если результат ложен, цикл завершается, и управление передается следующей инструкции после всего блока for.

Третье выражение — это инкремент (или декремент). Оно выполняется сразу после завершения тела цикла, но перед следующей проверкой условия. Здесь обычно происходит изменение значения счетчика, например, его увеличение на единицу (++) или уменьшение (--). Это выражение готовит переменную к следующей проверке условия.

for ($i = 0; $i < 5; $i++) {
    echo "Итерация $i\n";
}

Разбор:

  • В заголовке for три части: инициализация ($i = 0), условие ($i < 5) и шаг ($i++).
  • Тело выполняется, пока условие истинно, поэтому выводятся итерации от 0 до 4.
  • Изменение счетчика встроено в саму конструкцию, что делает контроль цикла прозрачным.
  • Этот формат удобен при заранее известном числе повторений.
  • Если нужна работа по коллекции, чаще предпочтительнее foreach.

В этом примере инициализация устанавливает переменную $i в значение 0. Условие $i < 5 проверяет, меньше ли текущее значение 5. Поскольку 0 меньше 5, выполняется тело цикла, которое выводит текст "Итерация 0". После этого срабатывает инкремент $i++, увеличивающий переменную до 1. Проверка условия повторяется. Процесс продолжается до тех пор, пока $i не станет равным 5. При значении 5 условие $i < 5 возвращает ложь, и цикл останавливается.

Компоненты:

  • Инициализация — один раз перед циклом.
  • Условие — проверяется перед каждой итерацией.
  • Инкремент — выполняется после каждой итерации.

Переменная цикла остаётся в области видимости после завершения.

Процесс работы цикла можно описать как замкнутый контур. Сначала система выполняет инициализацию. Затем она переходит к проверке условия. Если условие истинно, выполняется тело цикла. Сразу после этого выполняется выражение инкремента. После чего система снова возвращается к проверке условия. Этот цикл повторяется бесконечно, пока условие остается истинным.

Если условие изначально ложно (например, начальное значение больше предельного), тело цикла никогда не выполнится ни разу. Инициализация все равно произойдет, но проверка условия остановит выполнение до входа в блок кода.

Пример с обратным отсчетом демонстрирует использование декремента:

for ($j = 3; $j >= 0; $j--) {
    echo "Осталось секунд: $j\n";
}

Разбор:

  • Здесь используется декремент, поэтому цикл идет в обратном направлении.
  • Условие >= 0 включает ноль, значит вывод будет 3, 2, 1, 0.
  • При достижении -1 условие становится ложным и цикл завершается.
  • Паттерн часто нужен для countdown-логики и обратного перебора.
  • Важно не перепутать знак сравнения при обратном проходе.

Здесь инициализация ставит $j в 3. Условие $j >= 0 истинно. Выполняется вывод. Инкремент $j-- уменьшает значение до 2. Следующая проверка успешна. Цикл продолжается, пока $j не станет -1. При значении -1 условие $j >= 0 становится ложным, и цикл завершается.

Переменная, объявленная в части инициализации цикла for, в PHP остается доступной после завершения цикла в пределах текущей функции или скрипта. Поэтому при проектировании кода полезно сразу выбирать имена счетчиков так, чтобы они не конфликтовали с другими переменными.

Практически это означает следующее:

  • Если значение счетчика нужно после цикла, это поведение удобно и предсказуемо.
  • Если значение счетчика не нужно, лучше использовать короткое локальное имя ($i, $j) и не обращаться к нему после цикла.
  • Если цикл длинный и вложенный, стоит вынести обработку в отдельную функцию, чтобы ограничить область видимости естественным образом.

Пример ограничения области видимости:

for ($k = 0; $k < 3; $k++) {
    echo "Внутри: $k\n";
}
// echo "$k"; // В PHP переменная обычно остается доступной в текущей области

В данном случае попытка обратиться к $k после цикла обычно будет успешной, потому что переменная сохраняется в текущей области видимости. Проверка в комментарии полезна как напоминание о том, что счетчик не стоит использовать повторно без явного намерения.

Конструкция for допускает сложную логику в каждом из трех компонентов. В части инициализации можно объявлять несколько переменных, разделяя их запятыми. В условии можно использовать сложные логические выражения с операторами &&, || и !. В выражении инкремента можно изменять сразу несколько переменных или выполнять функции.

Пример множественной инициализации и сложного инкремента:

for ($x = 0, $y = 10; $x < $y; $x++, $y--) {
    echo "X: $x, Y: $y\n";
}

Здесь две переменные $x и $y инициализируются одновременно. Условие проверяет, меньше ли $x чем $y. После каждой итерации обе переменные изменяются: $x увеличивается, а $y уменьшается. Цикл останавливается, когда $x достигает значения $y.

Такая гибкость позволяет реализовать сложные алгоритмы поиска, сортировки и обработки данных в компактной форме. Важно следить за тем, чтобы выражение инкремента гарантированно приближало условие к ложному значению, иначе цикл превратится в бесконечный.

Цикл while​

Цикл while проверяет условие перед каждой итерацией.

Цикл while представляет собой механизм повторения выполнения блока кода, основанный на проверке условия перед началом каждого прохода. Этот инструмент предназначен для ситуаций, когда количество итераций заранее неизвестно или зависит от динамических изменений данных внутри тела цикла. Алгоритм работы строится на непрерывной проверке логического выражения: если оно истинно, выполняется код; если ложно — цикл завершается.

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

while (<условие>) {
    // тело цикла
}
$count = 3;
while ($count > 0) {
    echo "Осталось: $count\n";
    $count--;
}

Разбор:

  • while проверяет условие перед каждой итерацией и может не зайти в тело ни разу.
  • В примере $count-- гарантирует, что цикл когда-то завершится.
  • Такой стиль подходит, когда число повторений заранее неизвестно.
  • Состояние цикла обычно меняется внутри тела на каждом шаге.
  • Отсутствие обновления состояния приводит к бесконечному циклу.

Если условие изначально ложно, тело не выполняется ни разу.

Процесс запускается следующим образом. Сначала система вычисляет значение условия $count > 0. В примере переменная $count равна 3, поэтому условие возвращает истину. Скрипт переходит к выполнению тела цикла: выводит текст "Осталось: 3" и уменьшает переменную $count на единицу (становится 2).

После завершения тела цикла выполнение возвращается к началу структуры. Система снова проверяет условие $count > 0. Текущее значение 2 удовлетворяет условию, поэтому тело выполняется повторно. Выводится "Осталось: 2", счетчик уменьшается до 1. Процесс повторяется еще раз: вывод "Осталось: 1", счетчик становится 0.

При следующей проверке условие $count > 0 оказывается ложным, так как 0 не больше 0. Цикл немедленно завершается, и управление передается инструкции, следующей после закрывающей фигурной скобки. Текст "Осталось: 0" никогда не выводится, так как проверка происходит до входа в блок.

Ключевой особенностью цикла while является то, что условие проверяется до первой итерации. Если при первом запуске условие оказывается ложным, тело цикла не выполнится ни единого раза. Это отличает его от цикла do...while, где тело гарантированно выполняется хотя бы один раз.

Пример отсутствия выполнения:

$active = false;

while ($active) {
    echo "Этот текст не появится";
    // ... другие действия
}
echo "Цикл завершился сразу";

В данном случае переменная $active имеет значение false. Проверка условия $active возвращает ложь сразу же при старте. Блок кода пропускается полностью. Выполнение программы продолжается со строки после цикла, выводя сообщение о том, что цикл завершился сразу.

Это свойство делает конструкцию while идеальной для защиты от выполнения кода в недопустимых состояниях. Например, можно запустить цикл обработки очереди только тогда, когда очередь не пуста. Если очередь пуста с самого начала, цикл просто игнорируется без лишних действий.

Цикл while часто используется, когда условие выхода зависит от событий, происходящих внутри тела цикла. В отличие от цикла for, здесь нет явного счетчика в заголовке. Изменение переменной, влияющей на условие, должно происходить явно внутри блока кода.

Система будет проверять одно и то же условие бесконечно, пока скрипт не будет принудительно остановлен сервером или пользователем.

Пример бесконечного цикла:

$counter = 5;

while ($counter > 0) {
    echo "Бесконечность: $counter\n";
    // Отсутствует строка $counter--;
}

Здесь переменная $counter всегда равна 5. Условие $counter > 0 всегда истинно. Тело цикла выполняется бесконечно, выводя одну и ту же строку до исчерпания ресурсов памяти или времени выполнения.

Для предотвращения таких ситуаций необходимо гарантировать, что внутри тела цикла существует инструкция, изменяющая состояние переменных, участвующих в условии проверки.

Широкое применение цикл while находит при работе с внешними источниками данных, размер которых неизвестен заранее. Типичные сценарии включают чтение строк из файла, обработку входящих запросов или перебор элементов массива до достижения конца.

Пример чтения файла построчно:

$file = fopen('data.txt', 'r');

while (($line = fgets($file)) !== false) {
    echo "Обработана строка: $line\n";
    processLine($line);
}

fclose($file);

Функция fgets считывает следующую строку из файла и присваивает ее переменной $line. Если файл закончился, функция возвращает false. Условие цикла проверяет результат: пока строка не равна false, цикл продолжается. Как только конец файла достигнут, условие становится ложным, и чтение прекращается.

Такой подход позволяет обрабатывать файлы любого размера, не загружая их целиком в память. Цикл работает порционно, читая и обрабатывая данные по мере поступления.

Цикл do-while​

Цикл do-while гарантирует выполнение тела хотя бы один раз.

Цикл do-while представляет собой механизм повторения выполнения блока кода, который гарантирует выполнение тела цикла хотя бы один раз до первой проверки условия. Этот инструмент незаменим в сценариях, где действие должно произойти обязательно перед тем, как система получит возможность оценить результат и решить, продолжать ли работу. Алгоритм работы строится на последовательности — сначала выполняется код, затем проверяется условие, и только при истинности условия цикл повторяется.

Синтаксис конструкции начинается с ключевого слова do, за которым следует блок кода в фигурных скобках. После закрывающей скобки идет ключевое слово while, за которым следует условие в круглых скобках. Завершается вся конструкция обязательной точкой с запятой.

do {
    // тело цикла
} while (<условие>);
$input = '';
do {
    $input = readline('Введите число от 1 до 10: ');
    $number = (int)$input;
} while ($number < 1 || $number > 10);

В этом примере переменная $input изначально пуста. Цикл начинает работу — программа выводит приглашение ввести число, пользователь вводит значение, которое преобразуется в целое число $number. Сразу после этого выполняется проверка условия $number < 1 || $number > 10.

Если пользователь ввел число 5, условие ложно (5 не меньше 1 и не больше 10). Цикл завершается, и программа переходит к дальнейшей обработке числа 5.

Если пользователь ввел число 15, условие истинно (15 больше 10). Управление возвращается в начало блока do. Скрипт снова выводит приглашение и ждет нового ввода. Процесс повторяется до тех пор, пока пользователь не введет число в допустимом диапазоне.

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

Обязательна точка с запятой после while. Синтаксис цикла do-while требует строгого соблюдения правил пунктуации. Точка с запятой (;) ставится после закрывающей скобки условия в конце конструкции while (...).

} while ($condition); // Точка с запятой здесь обязательна

Отсутствие этой точки приводит к синтаксической ошибке интерпретатора PHP. Система ожидает завершения выражения, но встречает конец строки или другую инструкцию без разделителя. Это распространенная ошибка новичков, так как в цикле for точка с запятой стоит внутри скобок, а в цикле while она отсутствует вовсе. В случае do-while точка с запятой служит окончанием всей конструкции цикла.

Пример ошибки:

do {
    echo "Ошибка";
} while ($x < 10) // Ошибка: нет точки с запятой

Правильный вариант:

do {
    echo "Верно";
} while ($x < 10);

Процесс запуска происходит следующим образом. Система сразу переходит к выполнению тела цикла, игнорируя предварительную проверку условий. Код внутри блока выполняется полностью. Только после завершения всех инструкций тела управления передается следующая часть конструкции — проверка условия после слова while. Если условие возвращает истину, управление возвращается в начало блока do, и тело выполняется снова. Если условие ложно, цикл завершается, и выполнение продолжается со следующей инструкции программы.

Ключевым отличием от цикла while является отсутствие возможности пропустить тело цикла при старте. В цикле while условие проверяется перед первым входом, поэтому если оно изначально ложно, код не выполнится ни разу. В цикле do-while тело гарантированно выполнится минимум один раз, независимо от начального состояния переменных.

Типичный сценарий применения этого цикла — получение корректных данных от пользователя. Программа должна запросить ввод, обработать его, а затем проверить, соответствует ли он требованиям. Если требования не выполнены, запрос повторяется.

Основное различие между циклами заключается в моменте проверки условия. Цикл while проверяет условие перед каждой итерацией, включая первую. Это означает, что тело может не выполниться вообще. Цикл do-while проверяет условие после каждой итерации. Это означает, что тело выполнится всегда хотя бы один раз.

Как и в других типах циклов, существует риск создания бесконечного цикла, если условие никогда не станет ложным. В цикле do-while это особенно опасно, так как тело выполнится хотя бы один раз, и если логика изменения переменных внутри тела не приведет к изменению условия, процесс зациклится навсегда.

Цикл foreach​

Цикл foreach предназначен для итерации по массивам и объектам.

Цикл foreach представляет собой специализированный механизм перебора элементов коллекций в PHP. Этот инструмент создан исключительно для работы с массивами и объектами, реализующими интерфейс Traversable. Он автоматизирует процесс извлечения данных, устраняя необходимость в ручном управлении индексами или счетчиками. Алгоритм работы строится на последовательном доступе к каждому элементу коллекции до тех пор, пока не будут обработаны все доступные значения.

Синтаксис цикла начинается с ключевого слова foreach, за которым следует имя массива в фигурных скобках, ключевое слово as и имя переменной для текущего элемента. В этой конструкции переменная-счетчик не требуется, так как цикл сам управляет переходом от одного элемента к следующему.

По значениям:

foreach ($<массив> as $<элемент>) {
    // обработка элемента
}

При каждом проходе цикла система присваивает текущему элементу массива значение, которое копируется в указанную переменную. Эта переменная доступна только внутри тела цикла. После завершения обработки элемента управление передается следующему элементу. Если массив пуст, тело цикла не выполнится ни разу.

По ключам и значениям:

foreach ($<массив> as $<ключ> => $<значение>) {
    // обработка пары
}

Пример перебора списка оценок:

$scores = ['Анна' => 95, 'Борис' => 87];
foreach ($scores as $name => $score) {
    echo "$name: $score\n";
}

В данном примере циклу передаются только числовые значения (95 и 87). Ключи массива ("Анна", "Борис") игнорируются. Результатом работы будет вывод двух строк с оценками без имен студентов.

Для доступа к идентификаторам элементов используется расширенный синтаксис с оператором стрелки =>. В этом случае первая переменная принимает значение ключа, а вторая — значение элемента. Это позволяет обрабатывать пары "ключ-значение" одновременно.

Этот подход незаменим при работе с ассоциативными массивами, где ключи имеют смысловую нагрузку (имена, коды, идентификаторы). Система автоматически перебирает все пары, сохраняя связь между именем элемента и его данными.

Пример использования с именами студентов:

$scores = ['Анна' => 95, 'Борис' => 87];
foreach ($scores as $name => $score) {
    echo "$name: $score\n";
}

Здесь переменная $name получает значение ключа ('Анна', затем 'Борис'), а переменная $score — соответствующее значение (95, затем 87). Результатом является вывод полного списка с именами и оценками. Порядок обхода соответствует порядку добавления элементов в массив.

Модификация через ссылку:

foreach ($<массив> as &$<элемент>) {
    $<элемент> = <новое_значение>;
}
unset($<элемент>); // обязательный сброс ссылки

По умолчанию цикл foreach работает с копией значения элемента. Изменение переменной внутри тела цикла не влияет на исходный массив. Чтобы изменить данные в самом массиве, необходимо использовать оператор ссылки &. При объявлении переменной со знаком амперсанд (&) она становится ссылкой на оригинальный элемент, а не его копией.

$prices = [100, 200];
foreach ($prices as &$price) {
    $price *= 1.1;
}
unset($price);

Разбор:

  • Перебор по ссылке &$price позволяет менять элементы исходного массива на месте.
  • Операция $price *= 1.1 применяет трансформацию ко всем значениям.
  • unset($price) обязателен, чтобы разорвать ссылку после цикла.
  • Без unset последующие присваивания переменной могут случайно менять последний элемент массива.
  • Это мощный, но потенциально опасный режим foreach, требующий аккуратности.

В этом режиме изменение значения переменной сразу отражается в массиве. Это позволяет применять операции трансформации ко всем элементам без необходимости обращения к ним по индексам.

После выполнения этого кода массив $prices будет содержать значения 110 и 220. Переменная $price была ссылкой на каждый элемент по очереди, поэтому изменения сохранились в исходной структуре.

Управление потоком выполнения​

Операторы break и continue​

Оператор break прекращает выполнение цикла.
Оператор continue переходит к следующей итерации.

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

for ($i = 0; $i < 3; $i++) {
    for ($j = 0; $j < 3; $j++) {
        if ($i === 1 && $j === 1) {
            break 2; // выход из обоих циклов
        }
        echo "$i,$j ";
    }
}

Генераторы и yield​

Генераторы позволяют создавать ленивые последовательности без загрузки всех данных в память.

function xrange($start, $end) {
    for ($i = $start; $i <= $end; $i++) {
        yield $i;
    }
}

foreach (xrange(1, 5) as $n) {
    echo "$n ";
}

Разбор:

  • yield превращает функцию в генератор, который отдает элементы лениво по одному.
  • Такой подход экономит память по сравнению с созданием полного массива.
  • Генератор автоматически запоминает позицию между итерациями foreach.
  • Подходит для больших диапазонов, потоков и поэтапной обработки данных.
  • Для повторного обхода генератор вызывают заново, создавая новый экземпляр.

Генератор с ключами:

yield $key => $value;

Генератор можно итерировать только один раз. Для повторного использования вызывается заново.

Рекомендации​

  • Используйте === и !== для строгого сравнения.
  • Предпочитайте match вместо switch при выборе значения.
  • Избегайте модификации массива внутри foreach.
  • Всегда вызывайте unset() после foreach (&$ref).
  • Валидируйте входные данные до условий.
  • Не используйте and/or — их приоритет ниже ожидаемого.

Типовые ошибки новичков в условиях и циклах​

  • Использование = вместо == или === в условии (if ($x = 1)), что меняет значение переменной и искажает логику.
  • Сравнение результата strpos() без строгой проверки: позиция 0 корректна, но в if ($pos) воспринимается как ложь.
  • Смешивание ?? и ?: без понимания разницы: ?? проверяет только null, а ?: оценивает "истинность".
  • Отсутствие break в switch, когда проваливание не запланировано.
  • Изменение исходного массива в foreach по ссылке без unset($ref) после цикла.

Для закрепления полезно взять реальный обработчик формы и пройтись по нему по шагам — валидация входа, ветвление по ошибкам, успешная ветка с записью в БД. Сквозной пример есть в статье "От HTML-формы до записи в базу данных".

Основа по протоколу

Базовый разбор HTTP и HTTPS находится в отдельной статье — HTTP как основа веб-интеграций.

Содержание