PHP: полный мануал с примерами, функциями и ООП

<?php
$stock = 0;
if ($stock > 0) {
    echo "Есть в наличии\n";
} else {
    echo "Ожидаем поставку\n";
}
echo "Каталог доступен для просмотра\n";

Ожидаем поставку
Каталог доступен для просмотра

Последняя строка стоит после обеих ветвей и выполняется независимо от наличия. Замените 0 на 3: изменится только сообщение о наличии. После if (...) не ставят случайную ; — иначе получится отдельная пустая инструкция.

<?php
$stock = 2;
if ($stock === 0) {
    echo "Нет в наличии\n";
} elseif ($stock < 5) {
    echo 'Осталось мало: ', $stock, ' уп.', "\n";
} else {
    echo 'В наличии: ', $stock, ' уп.', "\n";
}

Осталось мало: 2 уп.

2 не равно 0, но 2 меньше 5; выбирается средний блок. Если поставить условие stock > 0 раньше stock < 5, общий случай перехватит маленький остаток. Заранее считаем stock неотрицательным целым; ошибки внешних данных обрабатываются до этой классификации.

<?php
$boxCount = 3;
for ($number = 1; $number <= $boxCount; $number = $number + 1) {
    echo 'Коробка ', $number, ' из ', $boxCount, "\n";
}
echo "Этикетки подготовлены\n";

Коробка 1 из 3
Коробка 2 из 3
Коробка 3 из 3
Этикетки подготовлены

После третьего тела number становится 4. Условие 4 <= 3 ложно, поэтому четвёртая этикетка не появляется. При boxCount = 0 тело не выполнится ни разу, но сообщение после цикла выполнится.

<?php
$remaining = 5;
$boxNumber = 1;
while ($remaining > 0) {
    $inBox = 2;
    if ($remaining < $inBox) {
        $inBox = $remaining;
    }
    echo 'Коробка ', $boxNumber, ': ', $inBox, ' уп.', "\n";
    $remaining = $remaining - $inBox;
    $boxNumber = $boxNumber + 1;
}
echo "Всё упаковано\n";

Коробка 1: 2 уп.
Коробка 2: 2 уп.
Коробка 3: 1 уп.
Всё упаковано

remaining проходит значения 5 → 3 → 1 → 0. В последней коробке if уменьшает порцию до 1, чтобы не упаковать несуществующий товар. Изменяемая величина и граница остановки видны непосредственно в коде.

<?php
$prepareAgain = false;
do {
    echo "Упаковочный стол подготовлен\n";
} while ($prepareAgain);
echo "Можно начать выдачу\n";

Упаковочный стол подготовлен
Можно начать выдачу

Тело сработало один раз; затем false остановил повтор. В этой форме после while (...) нужна ;. У обычного while (false) тело не выполнилось бы ни разу.

<?php
$stockByTitle = ['Чай' => 0, 'Кофе' => 2, 'Какао' => 1];
foreach ($stockByTitle as $title => $stock) {
    if ($stock === 0) {
        continue;
    }
    echo 'Можно заказать: ', $title, ' — ', $stock, ' уп.', "\n";
}
echo "Просмотр завершён\n";

Можно заказать: Кофе — 2 уп.
Можно заказать: Какао — 1 уп.
Просмотр завершён

continue не завершает функцию и не заканчивает весь цикл. Он пропускает оставшуюся часть только текущего прохода. Поэтому кофе и какао обработаны после отсутствующего чая. Здесь заранее заданные остатки — неотрицательные целые.

<?php
$stockByTitle = ['Чай' => 0, 'Кофе' => 2, 'Какао' => 1];
$preview = 'Сейчас нет доступных товаров';
foreach ($stockByTitle as $title => $stock) {
    if ($stock === 0) {
        continue;
    }
    $preview = 'Сегодня доступен: ' . $title;
    break;
}
echo $preview, "\n";

Сегодня доступен: Кофе

Чай пропущен. Кофе записан в preview, затем break выходит из foreach: Какао не рассматривается. Если все остатки нулевые или массив пустой, остаётся заранее подготовленная фраза об отсутствии. В отличие от return, break оставляет возможность выполнять код после цикла.

<?php
$deliveryMethod = 'pickup';
switch ($deliveryMethod) {
    case 'pickup':
        echo "Способ: самовывоз\n";
        echo "Получение с 10:00 до 19:00\n";
        break;
    case 'courier':
        echo "Способ: курьер\n";
        echo "Согласуем интервал доставки\n";
        break;
    default:
        echo "Выберите способ получения заказа\n";
}
echo "Спасибо за заказ\n";

Способ: самовывоз
Получение с 10:00 до 19:00
Спасибо за заказ

После двух строк pickup выполняется break, поэтому инструкции courier не идут следом. Без break switch способен продолжить следующую ветвь: это разрешённое поведение, которое легко получить случайно. Последний echo находится после switch и выполнится при любом варианте.

<?php
$deliveryMethod = 'pickup';
$label = match ($deliveryMethod) {
    'pickup' => 'Самовывоз',
    'courier' => 'Курьер',
    default => 'Способ не выбран',
};
echo 'Заказ 42. Получение: ', $label, "\n";

Заказ 42. Получение: Самовывоз

Выражение match возвращает строку Самовывоз, присваивание сохраняет её в label, а echo оформляет общую строку. Только выбранное выражение результата вычисляется; перехода в следующую ветвь нет.

<?php
$stock = 0;
$label = 'Нет в наличии';
if ($stock > 0) {
    $label = 'Можно заказать';
    echo "Показать кнопку покупки\n";
}
echo $label, "\n";

Нет в наличии

Без скобок if управлял бы только одной следующей инструкцией. Здесь присваивание подписи и вывод кнопки должны зависеть от одного условия.

<?php
$allowed = false;
// Намеренная ошибка для наблюдения:
if ($allowed);
{
    echo "Этот блок всё равно выполнился\n";
}
// Исправленная запись:
if ($allowed) {
    echo "Разрешённое действие\n";
}
echo "Проверка закончена\n";

Этот блок всё равно выполнился
Проверка закончена

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

<?php
$room = '0';
if ($room) {
    echo 'Ошибочный вариант: комната ', $room, "\n";
} else {
    echo "Ошибочный вариант потерял номер комнаты\n";
}
if ($room !== '') {
    echo 'Адрес доставки: комната ', $room, "\n";
}

Ошибочный вариант потерял номер комнаты
Адрес доставки: комната 0

Строка 0 ложна при логическом преобразовании, поэтому первый if пропускает полезную подпись. Вторая проверка задаёт конкретный вопрос: строка не пустая? Ответ true; номер попадает в адрес. Вход здесь заранее известен как строка. Внешнее значение сначала проверяют на строковый тип, иначе массив тоже не равен пустой строке.

<?php
$total = 7000;
if ($total >= 5000) {
    echo "Тариф: бесплатная доставка\n";
} elseif ($total >= 2000) {
    echo "Тариф: сниженная доставка\n";
} else {
    echo "Тариф: обычная доставка\n";
}
if ($total >= 2000) {
    echo "Начислить бонусы\n";
}
if ($total >= 5000) {
    echo "Показать подарок\n";
}

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

После первого подходящего тарифа остальные elseif не проверяются. Бонусы и подарок независимы, поэтому оба if выполняют свои действия. Это локальная модель правил, без платежей или записи в базу.

<?php
$signedIn = false;
$hasOrders = true;
// Намеренно запутанная запись без скобок:
if ($signedIn)
    if ($hasOrders)
        echo "Заказы\n";
else
    echo "Войти\n";
echo "После первой проверки\n";

if ($signedIn) {
    if ($hasOrders) {
        echo "Заказы\n";
    }
} else {
    echo "Войти\n";
}

После первой проверки
Войти

Первый else принадлежит hasOrders, до которого программа не дошла из-за signedIn=false. Во второй записи скобки явно прикрепляют else к проверке входа. HTML-кнопка сама по себе не является серверной проверкой доступа.

<?php $stock = 0; ?>
<?php if ($stock > 0): ?>
<p>Можно заказать</p>
<?php elseif ($stock === 0): ?>
<p>Пока закончился</p>
<?php else: ?>
<p>Уточните остаток</p>
<?php endif; ?>

<p>Пока закончился</p>

Код проверен в CLI: ожидаемый результат — байты HTML, которые сервер передал бы браузеру. В этом примере текст постоянный; пользовательские строки перед выводом экранируют.

<?php
$remaining = 1;
while ($remaining > 0):
    echo "W\n";
    $remaining--;
endwhile;
for ($label = 1; $label <= 2; $label++):
    echo 'F', $label, "\n";
endfor;
switch ('pickup'):
    case 'pickup':
        echo "Самовывоз\n";
        break;
    default:
        echo "Доставка\n";
endswitch;

W
F1
F2
Самовывоз

У do…while и match такой пары end-слов нет. Альтернативный foreach с экранированием уже показан ниже в примере списка товаров. declare будет разобран отдельно.

<?php
if (false):
    echo 'A';
else if (true):
    echo 'B';
endif;

Намеренная синтаксическая ошибка: после else ожидается двоеточие, а не if. Исправление: elseif (true):. Не смешивайте для одного блока двоеточие и закрывающую фигурную скобку.

<?php
switch ('pickup'): ?>
  <p>Промежуточный текст</p>
<?php case 'pickup':
    break;
endswitch;

Здесь текст является T_INLINE_HTML там, где нужны case/default/endswitch. Даже отправляемые пробелы могут стать причиной ошибки. Оставляйте первый case внутри того же PHP-участка; не полагайтесь на поглощение одного переноса строки закрывающим тегом.

<?php
$boxes = ['Чай', 'Кофе', 'Какао'];
for ($boxIndex = 0, $shelfNumber = 3; $shelfNumber >= 1; $boxIndex++, $shelfNumber--) {
    echo $boxes[$boxIndex], ': место ', $shelfNumber, "\n";
}
for ($number = 1; false, $number <= 2; $number++) {
    echo 'Проверка запятой: этикетка ', $number, "\n";
}

Чай: место 3
Кофе: место 2
Какао: место 1
Проверка запятой: этикетка 1
Проверка запятой: этикетка 2

В инициализации boxIndex получает 0, shelfNumber — 3. После каждой подписи первый увеличивается, второй уменьшается: пары 0/3, 1/2, 2/1. Когда shelfNumber становится 0, тело больше не выполняется. Второй цикл намеренно показывает ловушку: false перед запятой не запрещает проход, решение задаёт последнее выражение number <= 2. Для двух обязательных условий используют &&.

<?php
$attempt = 1;
for (;;) {
    echo 'Попытка ', $attempt, "\n";
    if ($attempt === 2) {
        break;
    }
    $attempt++;
}

Попытка 1
Попытка 2

Этот опыт ограничен двумя проходами. При известном пределе обычный for с attempt<=2 короче объясняет цель. Пустые части полезно узнавать в чужом коде, но они не снимают обязанность обеспечить остановку.

<?php
function numberOfLabels(): int
{
    echo "Получаем число этикеток: 2\n";
    return 2;
}
echo "Первый вариант\n";
for ($number = 1; $number <= numberOfLabels(); $number++) {
    echo 'Этикетка заказа №', $number, "\n";
}
echo "Второй вариант\n";
$limit = numberOfLabels();
for ($number = 1; $number <= $limit; $number++) {
    echo 'Этикетка заказа №', $number, "\n";
}

Первый вариант
Получаем число этикеток: 2
Этикетка заказа №1
Получаем число этикеток: 2
Этикетка заказа №2
Получаем число этикеток: 2
Второй вариант
Получаем число этикеток: 2
Этикетка заказа №1
Этикетка заказа №2

NumberOfLabels каждый раз возвращает int 2 прямо в сравнение number <= ... . Поэтому первый вариант вызывает её трижды: перед номерами 1, 2 и неуспешной проверкой 3. Второй сохраняет return 2 в limit один раз. Это правильно, только если число этикеток не должно меняться во время цикла. Функция учебная: сообщения показывают вызовы, сетевой запрос не выполняется.

<?php
$running = true;
while ($running) {
    echo "Начали проход\n";
    $running = false;
    echo "Закончили начатый проход\n";
}
echo "После цикла\n";

Начали проход
Закончили начатый проход
После цикла

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

<?php
$number = 0;
while ($number < 4) {
    $number++;
    if ($number === 2) {
        continue;
    }
    echo $number, "\n";
}

1
3
4

При number=2 остаток тела пропускается, но счётчик уже увеличен. Если поставить единственный ++ после continue, можно застрять на значении 2. В интеграции кроме числа повторов нужны сроки и договор повторного запроса.

<?php
$email = '';
$result = 'Отправка не подготовлена';
do {
    if ($email === '') {
        $result = 'Не указан адрес';
        break;
    }
    $result = 'Можно подготовить письмо';
} while (false);
echo $result, "\n";
echo "Общий итог записан\n";

Не указан адрес
Общий итог записан

Письмо не отправляется: показан лишь выбор результата. Для нового кода ту же задачу часто проще выразить функцией с ранним return или if/else. do…while не имеет альтернативного enddo-синтаксиса; после while(...) нужна ;.

<?php
$stocks = ['TEA-01' => 2, 'COF-02' => 3];
foreach ($stocks as $stock) {
    $stock += 10;
}
echo "После изменения только переменной цикла\n";
foreach ($stocks as $sku => $stock) {
    echo $sku, ': ', $stock, ' шт.', "\n";
}
foreach ($stocks as $sku => $stock) {
    $stocks[$sku] = $stock + 10;
}
echo "После записи в элемент склада\n";
foreach ($stocks as $sku => $stock) {
    echo $sku, ': ', $stock, ' шт.', "\n";
}

После изменения только переменной цикла
TEA-01: 2 шт.
COF-02: 3 шт.
После записи в элемент склада
TEA-01: 12 шт.
COF-02: 13 шт.

В первом цикле stock по очереди получает 2 и 3, но увеличение этого отдельного имени не пишет в массив stocks. Во втором изменяющем цикле sku получает ключ TEA-01 или COF-02; запись stocks[sku] адресует реальный элемент. Последующий отчёт читает уже 12 и 13. Для объектов значение элемента содержит идентификатор объекта: изменение свойства — отдельное правило, оно не отменяет разницу присваиваний.

<?php
$items = ['Чай', 'Кофе'];
echo current($items), "\n";
foreach ($items as $item) {
    echo $item, "\n";
}
echo current($items), "\n";

Чай
Чай
Кофе
Чай

current смотрит на внутренний указатель массива; foreach имеет свой механизм обхода. Не используйте current как способ узнать, на каком элементе сейчас находится foreach.

<?php
$rows = [['A', 'internal-1', 2], ['B', 'internal-2', 0]];
foreach ($rows as [$sku, , $quantity]) {
    echo $sku, ':', $quantity, "\n";
}
foreach ($rows as list($sku)) {
    echo 'Код ', $sku, "\n";
}

A:2
B:0
Код A
Код B

Лишние позиции не мешают: их можно не назначать переменным. Недостающая позиция в PHP 8 вызывает предупреждение Undefined array key и даёт null; старые описания могут называть это notice. Поэтому произвольную внешнюю строку до распаковки проверяют.

<?php
$rows = [['quantity' => 2, 'sku' => 'A'], ['sku' => 'B', 'quantity' => 0]];
foreach ($rows as ['sku' => $sku, 'quantity' => $quantity]) {
    echo $sku, ':', $quantity, "\n";
}

A:2
B:0

Ключи выбираются явно, поэтому перестановка полей не меняет смысл. Это распаковка уже проверенной схемы, а не проверка наличия и типов полей. Подробные варианты находятся в главе массивов.

<?php
class StockSummary {
    public $available = 4;
    private $internalLimit = 100;
}
$summary = new StockSummary();
var_dump(is_iterable($summary));
foreach ($summary as $name => $value) {
    echo $name, ':', $value, "\n";
}

bool(false)
available:4

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

<?php
$rows = ['A' => 'normal', 'B' => 'skip', 'C' => 'stop'];
foreach ($rows as $id => $type) {
    switch ($type) {
        case 'skip':
            continue 2;
        case 'stop':
            echo 'Остановка на ', $id, "\n";
            break 2;
        default:
            break;
    }
    echo 'Обработана ', $id, "\n";
}
echo "После обхода\n";

Обработана A
Остановка на C
После обхода

break в default завершил только switch, поэтому A дошла до общего вывода. B целиком пропущена. break 2 на C завершил и switch, и foreach. Ни одна из конструкций не завершает окружающую функцию — это сделал бы return.

<?php
for ($number = 1; $number <= 3; $number++) {
    if ($number === 2) {
        continue;
    }
    echo $number, "\n";
}
echo 'После цикла: ', $number, "\n";

1
3
После цикла: 4

continue не перескакивает мимо шага for. Это отличается от ручного ++ в конце тела while, который continue способен пропустить.

<?php
$levels = 1;
while (true) {
    break $levels;
}

В PHP 8 уровень задают положительным целым литералом и не превышают число охватывающих конструкций. Переменная здесь недопустима. Это compile error, а не случай, который можно поймать соседним catch.

<?php
switch ('skip') {
    case 'skip':
        continue;
}

Форма распознаётся, но начиная с PHP 7.3 выдаёт E_WARNING: continue целится в switch и ведёт себя как break. Для выхода из switch пишите break; для внешнего цикла — соответствующий уровень continue. Здесь фрагмент только lint-проверяется.

<?php
$verbosity = 'debug';
switch ($verbosity) {
    case 'debug':
        echo "Технические подробности\n";
        // Намеренно продолжаем: debug включает и info.
    case 'info':
        echo "Ход обработки\n";
        // Оба режима включают итог.
    default:
        echo "Итог\n";
}

Технические подробности
Ход обработки
Итог

Это осознанный каскад для локального отчёта. В выборе одного тарифа такое отсутствие break было бы ошибкой. Когда общий вывод нужен всегда, часто проще вынести его после switch.

<?php
function selectedMethod()
{
    echo "Читаем способ\n";
    return 'locker';
}
switch (selectedMethod()) {
    case 'pickup':
    case 'locker':
        echo "Получение в пункте\n";
        break;
    case 'courier':
        echo "Получение дома\n";
        break;
    default:
        echo "Способ неизвестен\n";
}

Читаем способ
Получение в пункте

Пустой case объединяет варианты. Сложность selectedMethod не умножилась на число сравнений, но это не универсальное обещание, что switch быстрее if: значение можно заранее сохранить и для if.

<?php
$weight = 7;
switch (true) {
    case $weight <= 2:
        echo "Малая посылка\n";
        break;
    case $weight <= 10:
        echo "Средняя посылка\n";
        break;
    default:
        echo "Крупная посылка\n";
}

Средняя посылка

Каждый case даёт bool, который сравнивается с true. Нельзя механически поставить switch($weight), оставив логические case: это будут не те сравнения. Вход примера заранее проверен как положительный вес.

<?php
$code = '1';
switch ($code) {
    case 1:
        echo "switch: совпало с числом\n";
        break;
}
echo match ($code) {
    1 => 'match: число',
    '1' => 'match: строка',
}, "\n";

switch: совпало с числом
match: строка

Внешние коды часто приходят строками. Выберите тип по договору API; не исправляйте любой непонятный вход простым (int), который может превратить мусор в 0.

<?php
function candidate($value)
{
    echo 'Проверка ', $value, "\n";
    return $value;
}
function unusedResult()
{
    echo "Чужой результат\n";
    return 'unused';
}
$label = match (2) {
    candidate(1) => unusedResult(),
    candidate(2), candidate(3) => 'Подготовлено',
    default => 'Нет варианта',
};
echo $label, "\n";

Проверка 1
Проверка 2
Подготовлено

candidate выводит метку проверки и возвращает переданный код. Проверка 3 и unusedResult не нужны. Правая часть ветки — одно выражение; несколько последовательных действий вынесите в понятную функцию или используйте обычный блок if/switch.

<?php
try {
    $fee = match ('unknown') {
        'pickup' => 0,
        'courier' => 300,
    };
} catch (UnhandledMatchError) {
    echo "Нет правила доставки\n";
}
$weight = 7;
$size = match (true) {
    $weight <= 2 => 'S',
    $weight <= 10 => 'M',
    default => 'L',
};
echo $size, "\n";

Нет правила доставки
M

Полнота match означает, что для текущего значения нужен подходящий вариант или default. PHP не доказывает при компиляции полноту вашего предметного справочника. Повторный default запрещён. В match(true) условия должны возвращать именно bool; произвольное число не тождественно true.

<?php
declare(strict_types=1);
require __DIR__ . '/boxes.php';
try {
    itemsInBoxes('2');
} catch (TypeError) {
    echo "Строгий вызов: строка количества отклонена\n";
}
$items = itemsInBoxes(2);
echo 'Накладная строгого вызова: ', $items, ' предметов', "\n";
require __DIR__ . '/weak-caller.php';

Строгий вызов: строка количества отклонена
Накладная строгого вызова: 12 предметов
Накладная нестрогого вызова: 12 предметов

Первый вызов передаёт строку "2" из строгого example.php: TypeError возникает до тела функции. Второй передаёт int 2; местный boxes получает 2, return возвращает 12 в items, echo использует его в накладной. При подключении weak-caller.php исполняется вызов, записанный уже в этом файле: строка "2" допускает приведение к int 2 и тоже даёт 12. Место объявления функции не сделало все вызовы строгими. Проверку возвращаемого типа определяет файл объявления; int допустим для float. Вызовы через внутренние функции имеют отдельные особенности.

<?php
const INTERVAL = 2;
declare(ticks=INTERVAL);

Директивы требуют буквального значения в исходнике. Исправление — declare(ticks=2);, а не const или переменная. Это проверка компиляции.

<?php
$stage = 'Начало';
$lastSeen = $stage;
$seen = [];
$handler = function () use (&$stage, &$lastSeen, &$seen) {
    if ($stage !== $lastSeen) {
        $seen[] = $stage;
        $lastSeen = $stage;
    }
};
register_tick_function($handler);
try {
    declare(ticks=1):
        $stage = 'Товары собраны';
        $stage = 'Заказ упакован';
    enddeclare;
} finally {
    unregister_tick_function($handler);
}
declare(ticks=1) {
    $stage = 'Передан в доставку';
}
foreach ($seen as $observed) { echo 'Наблюдали: ', $observed, "\n"; }
echo 'Текущий этап: ', $stage, "\n";

Наблюдали: Товары собраны
Наблюдали: Заказ упакован
Текущий этап: Передан в доставку

После двух присваиваний участка ticks=1 обработчик замечает строки этапов и добавляет их в seen. Дополнительное событие без изменения stage не добавит дубликат. Finally снимает именно handler. Последующий участок меняет stage на «Передан в доставку», но записи этого этапа в seen нет: функция больше не зарегистрирована. Echo показывает и настоящий список наблюдений, и текущее значение. Это не утверждение о двух tick-событиях: число событий и число записанных изменений — разные величины. Явные записи журнала в нужных местах прикладной операции обычно легче контролировать.

<?php
declare(encoding='UTF-8');
namespace Workshop\Source;
echo "Исходник UTF-8\n";

Контекстный фрагмент: запуск зависит от mbstring и zend.multibyte, включённого до компиляции. С namespace разрешена форма declare(encoding='…');, а не оборачивающий namespace блок declare(...){...}. Эта директива не заменяет header('Content-Type: ...; charset=UTF-8') и не преобразует автоматически данные внешнего API.

<?php
function showDiscount($enabled)
{
    if (!$enabled) {
        return;
    }
    echo "Скидка включена\n";
}
var_dump(showDiscount(false));
showDiscount(true);
echo "Основная программа продолжается\n";

NULL
Скидка включена
Основная программа продолжается

false привёл к раннему return без вывода. В успешной ветке echo делает действие; конец функции тоже даёт null, но второй вызов не отправлен в var_dump. Возврат и побочный вывод — независимые вещи.

<?php
echo "Начинаем чек\n";
$settings = require __DIR__ . '/settings.php';
$itemsTotal = 300;
$total = $itemsTotal + $settings['delivery'];
echo $settings['shop'], ': ', $total, ' руб.', "\n";
echo "Чек завершён\n";
return;
echo "Эта строка основного файла не выполняется\n";

Начинаем чек
Мастерская: 350 руб.
Чек завершён

Return внутри settings.php отдаёт массив в выражение require. Затем внешнее присваивание сохраняет его в settings и основной файл продолжает работу: берёт delivery=50 и считает 300+50=350. Код после return в дочернем файле не исполняется. Позднее отдельный return основного example.php завершает уже его код: последняя строка не печатается. В каждом случае границу задаёт место return. Это не установка системного кода завершения процесса через exit.

<?php
$title = 'Общий каталог';
function showLine($title, $price, $quantity): int {
    include __DIR__ . '/line.php';
    return $rowTotal;
}
$orderTotal = showLine('Чай', 150, 2);
echo 'К оплате: ', $orderTotal, ' руб.', "\n";
echo 'Внешний заголовок: ', $title, "\n";

Чай: 2 × 150 = 300 руб.
К оплате: 300 руб.
Внешний заголовок: Общий каталог

Вызов showLine передаёт три аргумента в местные параметры: Чай, 150 и 2. Include исполняет line.php в этой области: созданный там rowTotal=300 доступен следующему return функции. Число возвращается в orderTotal и используется в итоге. Внешний title остаётся «Общий каталог», потому что параметр title принадлежит вызову. RowTotal не появился снаружи; его значение вышло через return. Если убрать return функции, присваивание orderTotal не получит расчёт автоматически. В HTML-шаблоне дополнительно нужно экранировать данные по контексту.

<?php
function loadOrderHelpers(): string {
    return include __DIR__ . '/helpers.php';
}
$loadMessage = loadOrderHelpers();
echo $loadMessage, "\n";
$number = orderPrefix() . '-41';
echo 'Накладная: ', $number, "\n";

Правило номера загружено
Накладная: ORD-41

Внутренний include получает строку из return файла; внешний return loadOrderHelpers передаёт её в loadMessage. Безусловная функция orderPrefix объявлена в helpers.php и доступна после загрузки, хотя её текст ниже return. Её вызов возвращает ORD в соединение со строкой -41, результат ORD-41 сохраняется в number. Условные объявления функций имеют другие правила времени регистрации. Строка echo после return не исполняется; чтение файла внутри функции не сделало объявление orderPrefix локальным.

<?php
$oldPath = get_include_path();
set_include_path(__DIR__ . '/library');
try {
    $settings = include 'settings.php';
    echo $settings['shop'], ': ', 300 + $settings['delivery'], ' руб.', "\n";
    $settings = include __DIR__ . '/settings.php';
    echo $settings['shop'], ': ', 300 + $settings['delivery'], ' руб.', "\n";
} finally {
    set_include_path($oldPath);
}

Библиотечное правило: 350 руб.
Местное правило: 380 руб.

Первое имя без пути найдено в include_path: массив содержит доставку 50, поэтому чек равен 350. Второе подключение задаёт полный путь от __DIR__, выбирает местный файл с доставкой 80 и даёт 380. Прежняя переменная settings получает новое значение. Это два самостоятельных источника, не магическая перезапись одного файла. Если программа обязана брать конкретную настройку, явный путь делает выбор понятным.

<?php
$page = 'help';
$views = ['help' => __DIR__ . '/views/help.php'];
if (!is_string($page) || !isset($views[$page])) {
    echo "Раздел не найден\n";
} else {
    include $views[$page];
}

<p>Помощь покупателю</p>

page — код, не фрагмент пути. При значении '../private' ветка подключения не выполнится. В реальном HTTP-входе сначала проверяют тип параметра, права на раздел и подходящий статус ответа; подбор имени файла сам по себе не является авторизацией.

<?php
$headerStatus = include __DIR__ . '/heading.php';
echo 'Результат подключения заголовка: ', $headerStatus, ' (', get_debug_type($headerStatus), ')', "\n";
$settings = require __DIR__ . '/settings.php';
$itemsTotal = 300;
$payable = $itemsTotal + $settings['delivery'];
echo 'Магазин: ', $settings['shop'], "\n";
echo 'К оплате: ', $payable, ' руб.', "\n";
$optional = include __DIR__ . '/optional.php';
if ($optional === false) {
    echo "Необязательная возможность отключена настройкой файла\n";
}

Чек заказа
Результат подключения заголовка: 1 (int)
Магазин: Мастерская
К оплате: 350 руб.
Необязательная возможность отключена настройкой файла

Heading.php печатает заголовок и заканчивается без return: конструкция include даёт int 1 в headerStatus. Settings.php ничего не печатает, а возвращает массив; settings получает его, доставка 50 используется вместе с товарами 300. Optional.php успешно исполняется и намеренно возвращает false. Поэтому один false не доказывает ошибку открытия: нужен договор подключаемого файла и диагностика.

<?php
$title = '<Чай>';
ob_start();
try {
    require __DIR__ . '/message.php';
    $html = ob_get_contents();
} finally {
    ob_end_clean();
}
echo 'Содержимое: ', $html, "\n";

Содержимое: <strong>&lt;Чай&gt;</strong>

Буфер собирает вывод доверенного шаблона, а не его return. finally закрывает собственный буфер и при исключении. Этот шаблон сам не меняет уровни буферизации. В реальном приложении договор владения буфером должен быть явным; письмо здесь не отправляется.

<?php
$diagnostic = '';
set_error_handler(function ($severity, $message) use (&$diagnostic) {
    $diagnostic = 'Необязательный файл настроек не прочитан';
    return true;
}, E_WARNING);
try {
    $settings = include __DIR__ . '/absent.php';
} finally {
    restore_error_handler();
}
if ($settings === false) {
    echo $diagnostic, "\n";
    $settings = ['delivery' => 50];
}
echo 'Чек с запасным правилом: ', 300 + $settings['delivery'], ' руб.', "\n";

Необязательный файл настроек не прочитан
Чек с запасным правилом: 350 руб.

Файл absent.php намеренно отсутствует. Include выдаёт предупреждения; временный callback получает severity/message, сохраняет наше диагностическое сообщение и возвращает true, принимая обработку предупреждения на себя. Сам include всё равно даёт false в settings. После восстановления обработчика программа выбирает заранее разрешённое запасное значение 50 и считает 350. Этот договор разрешает только массив либо отказ открытия: произвольный корректный return false у существующего файла потребовал бы отдельного различения. Обработчик здесь относится к узкому учебному участку, а не скрывает все ошибки приложения.

<?php
$diagnostic = '';
set_error_handler(function ($severity, $message) use (&$diagnostic) {
    $diagnostic = 'Обязательный файл правил не прочитан';
    return true;
}, E_WARNING);
try {
    $settings = require __DIR__ . '/absent.php';
    echo 'Чек: ', 300 + $settings['delivery'], ' руб.', "\n";
} catch (Error) {
    echo $diagnostic, "\n";
    echo "Чек не сформирован: исправьте комплект файлов\n";
} finally {
    restore_error_handler();
}
echo "Обработка отказа завершена\n";

Обязательный файл правил не прочитан
Чек не сформирован: исправьте комплект файлов
Обработка отказа завершена

Require того же отсутствующего файла сначала даёт предупреждение, затем выбрасывает Error. Обработчик предупреждений не отменяет Error. Присваивание settings не получает результат, строка расчёта после require пропускается, catch показывает отказ. Finally восстанавливает прежний обработчик, затем выполняется общий код. Без catch необработанный Error прервал бы обычное выполнение. Это демонстрация отсутствия файла; ParseError внутри найденного файла — другая причина, её нельзя выдавать за нормальную необязательную настройку.

<?php
$settings = require_once __DIR__ . '/settings.php';
$secondResult = require_once __DIR__ . '/settings.php';
if ($secondResult === true) {
    echo "Повторное исполнение settings.php пропущено\n";
}
$totals = [300, 500];
foreach ($totals as $itemsTotal) {
    $payable = $itemsTotal + $settings['delivery'];
    echo $settings['shop'], ': к оплате ', $payable, ' руб.', "\n";
}
$thirdResult = include_once __DIR__ . '/settings.php';
echo 'Тип третьего результата: ', get_debug_type($thirdResult), "\n";

Настройки прочитаны
Повторное исполнение settings.php пропущено
Мастерская: к оплате 350 руб.
Мастерская: к оплате 550 руб.
Тип третьего результата: bool

Первый require_once выполнил файл: видна строка «Настройки прочитаны», а return передал массив в settings. Повторный require_once дал true в secondResult, не повторяя чтение. Два чека используют сохранённый settings, не второй bool. Include_once разделяет сведения о ранее включённых файлах: третий результат тоже true. Once относится к текущему процессу/запросу, не ко всем посетителям сайта.

<?php
$orderId = 41;
include __DIR__ . '/heading.php';
$orderId = 42;
$result = include_once __DIR__ . '/heading.php';
if ($result === true) {
    echo "Once пропустил повторный заголовок\n";
}
include __DIR__ . '/heading.php';

Заказ №41
Once пропустил повторный заголовок
Заказ №42

Обычный include уже выполнил heading.php при orderId=41. Следующий include_once учитывает это подключение, пропускает файл и даёт true: изменение переменной до 42 не заставляет once снова отобразить шаблон. Последний обычный include выполняет файл ещё раз и печатает новый номер 42. Once полезен для загрузки определений; повторяемое отображение шаблона имеет другой договор. Файл здесь только печатает заголовок, функций не объявляет.

<?php
$shelves = ['А' => ['TEA', 'COFFEE'], 'Б' => ['CUP', 'PLATE']];
$requested = 'CUP';
$foundShelf = null;
foreach ($shelves as $shelf => $skus) {
    foreach ($skus as $sku) {
        if ($sku === $requested) {
            $foundShelf = $shelf;
            goto searchFinished;
        }
    }
}
searchFinished:
if ($foundShelf === null) {
    echo 'Артикул ', $requested, ' не найден', "\n";
} else {
    echo 'Возьмите ', $requested, ' с полки ', $foundShelf, "\n";
}

Возьмите CUP с полки Б

Внешний foreach сначала выбирает полку А, внутренний проверяет TEA/COFFEE. Затем shelf=Б, первый sku=CUP совпадает: в foundShelf записывается Б, goto переносит исполнение к метке после обоих циклов. Дальнейшая проверка читает сохранённое Б и составляет поручение. PLATE не посещается. Если заменить запрос на SPOON, обход закончится обычным путём, foundShelf останется null и будет сообщение об отсутствии. Метка не вызывает функцию и не передаёт параметры.

<?php
function shelfForSku(array $shelves, string $requested): ?string {
    foreach ($shelves as $shelf => $skus) {
        foreach ($skus as $sku) {
            if ($sku === $requested) { return $shelf; }
        }
    }
    return null;
}
$shelves = ['А' => ['TEA', 'COFFEE'], 'Б' => ['CUP', 'PLATE']];
$location = shelfForSku($shelves, 'CUP');
echo 'Место для CUP: ', $location ?? 'не найдено', "\n";
$location = shelfForSku($shelves, 'SPOON');
echo 'Место для SPOON: ', $location ?? 'не найдено', "\n";

Место для CUP: Б
Место для SPOON: не найдено

Два аргумента становятся местными shelves и requested. При CUP внутренний if находит совпадение, return отдаёт Б из всего вызова в location. При SPOON завершаются оба цикла и последний return отдаёт null; ?? выбирает подпись «не найдено». : ?string допускает строку либо null. Данные полок здесь заранее имеют строковые ключи и списки артикулов. Это тот же линейный поиск с другим выражением границы выхода; если артикул встречается дважды, выбирается первая найденная полка.

<?php
goto inside;
for ($i = 0; $i < 2; $i++) {
inside:
    echo $i;
}

Компиляция отвергает goto внутрь loop/switch. Нельзя перескочить подготовку и управление конструкцией. Это отдельный запрещённый фрагмент, он не выполняется.

<?php
function readQuantity($value)
{
    if (!is_int($value) || $value < 0) {
        throw new InvalidArgumentException('Нужно неотрицательное целое');
    }
    return $value;
}
try {
    $quantity = readQuantity('bad');
    echo "Эта строка не выполняется\n";
} catch (InvalidArgumentException $error) {
    echo $error->getMessage(), "\n";
}
echo "После обработки отказа\n";

Нужно неотрицательное целое
После обработки отказа

new создаёт объект исключения; catch получает его в error, а ->getMessage() читает сообщение. Это контролируемый текст нашего примера. Сообщения внутренних SQL/файловых ошибок нельзя бездумно показывать посетителю.

<?php
$record = [];
try {
    $id = $record['id'] ?? throw new UnexpectedValueException('Нет ID');
} catch (UnexpectedValueException $error) {
    echo $error->getMessage(), "\n";
}
try {
    throw new stdClass();
} catch (Error) {
    echo "Бросать можно только Throwable\n";
}

Нет ID
Бросать можно только Throwable

Первый опыт проверяет отсутствие/null ID, но не его формат — это следующий шаг валидации. До PHP 8 throw был только инструкцией; современная форма позволяет ветке выражения завершиться исключением. stdClass — обычный объект, поэтому второй опыт специально получает Error.

<?php
try {
    throw new InvalidArgumentException('Неверная строка');
} catch (InvalidArgumentException $error) {
    echo "Исправить вход\n";
} catch (Throwable $error) {
    echo "Общий отказ\n";
}
try {
    throw new LengthException('Слишком много строк');
} catch (LengthException | UnexpectedValueException) {
    echo "Отчёт не соответствует договору\n";
}
echo "После обоих try\n";

Исправить вход
Отчёт не соответствует договору
После обоих try

Вертикальная черта объединяет допустимые типы catch с PHP 7.1; это не битовая операция над ошибками. Переменную можно не указывать с PHP 8.0, если объект не нужен. При нормальном завершении try все catch пропускаются.

<?php
try {
    try {
        throw new InvalidArgumentException('Строка не разобрана');
    } catch (InvalidArgumentException $error) {
        echo "Добавляем контекст импорта\n";
        throw new RuntimeException('Импорт остановлен', 0, $error);
    } catch (RuntimeException) {
        echo "Этот соседний catch не выполняется\n";
    }
} catch (RuntimeException $error) {
    echo $error->getMessage(), "\n";
    echo $error->getPrevious()->getMessage(), "\n";
}

Добавляем контекст импорта
Импорт остановлен
Строка не разобрана

Соседние catch обслуживают исходный try, а не исключения друг друга. Третий параметр конструктора сохраняет исходную причину; getPrevious читает её. Если новый контекст не нужен, throw $error повторно передаёт тот же объект.

<?php
function readFirstLine($path)
{
    $stream = fopen($path, 'r');
    if ($stream === false) {
        throw new RuntimeException('Не удалось открыть файл');
    }
    try {
        $line = fgets($stream);
        if ($line === false) {
            throw new UnexpectedValueException('Нет строки');
        }
        return trim($line);
    } finally {
        fclose($stream);
        echo "Поток закрыт\n";
    }
}
echo readFirstLine(__DIR__ . '/report.txt'), "\n";
try {
    readFirstLine(__DIR__ . '/empty.txt');
} catch (UnexpectedValueException) {
    echo "Отчёт пуст\n";
}

Поток закрыт
Отчёт готов
Поток закрыт
Отчёт пуст

Текст готового результата вычислен в try, но сначала выполняется fclose и метка из finally. Пустой fixture вызывает отказ, а поток также закрывается. Файлы ограничены и локальны; это не полный импорт произвольного большого отчёта.

<?php
try {
    try {
        throw new RuntimeException('Сбой чтения');
    } finally {
        echo "Освободили внутренний ресурс\n";
    }
} catch (RuntimeException) {
    echo "Обработали отказ снаружи\n";
} finally {
    echo "Закончили внешний участок\n";
}

Освободили внутренний ресурс
Обработали отказ снаружи
Закончили внешний участок

Порядок определяется вложенностью. Для одного try с catch и finally сначала работает его catch, затем finally. При раскрутке стека внутренний finally может встретиться раньше внешнего catch.

<?php
function preparedValue()
{
    $status = 'ready';
    try {
        return $status;
    } finally {
        $status = 'closed';
    }
}
function replacedValue()
{
    try {
        return 'ready';
    } finally {
        return 'closed'; // Намеренная ловушка для сравнения.
    }
}
echo preparedValue(), "\n";
echo replacedValue(), "\n";

ready
closed

В первом случае возвращаемая строка уже вычислена. Во втором новый return подменил её. Это пример скалярного значения; у возвращаемого объекта изменения его свойств могут быть видны через тот же идентификатор.

<?php
try {
    try {
        throw new RuntimeException('Импорт', 0, new Exception('Строка'));
    } finally {
        throw new LogicException('Журнал', 0, new Exception('Диск'));
    }
} catch (Throwable $error) {
    do {
        echo $error->getMessage(), "\n";
        $error = $error->getPrevious();
    } while ($error !== null);
}

Журнал
Диск
Импорт
Строка

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

<?php
try {
    echo "Завершаем процесс\n";
    exit(0);
} finally {
    echo "Эта строка не выполняется\n";
}

Завершаем процесс

Каждый учебный запуск работает в отдельном PHP-процессе; exit 0 завершает только его. В библиотеке не подменяйте им возвращаемый результат или исключение, которое вызывающий код должен обработать.

<?php
function reportRows()
{
    try {
        yield 'A';
        yield 'B';
    } finally {
        echo "Генератор закрыт\n";
    }
}
$rows = reportRows();
foreach ($rows as $row) {
    echo $row, "\n";
    break;
}
echo "Ссылка ещё сохранена\n";
unset($rows);
echo "После освобождения\n";

A
Ссылка ещё сохранена
Генератор закрыт
После освобождения

Здесь нет других ссылок и циклических зависимостей: unset освобождает именно последний сохранённый генератор. В сложном приложении время жизни задаёт владелец ресурса; не рассчитывайте на магическое закрытие от любого break.

<?php
function transientRows()
{
    try {
        yield 'R-1';
        yield 'R-2';
    } finally {
        echo "Источник освобождён\n";
    }
}
try {
    foreach (transientRows() as $row) {
        echo $row, "\n";
        throw new RuntimeException('Потребитель отказался');
    }
} catch (RuntimeException) {
    echo "Отказ обработан снаружи\n";
}

R-1
Источник освобождён
Отказ обработан снаружи

Ошибка возникла в потребителе, не внутри тела генератора: его собственный catch не должен автоматически её получить. Здесь временный генератор больше никем не удерживается, поэтому finally исполнился до внешнего catch.

<?php
function unfinishedRows()
{
    try {
        yield 'A';
    } finally {
        yield 'B';
    }
}
$rows = unfinishedRows();
$rows->current();
unset($rows);

Синтаксис допустим, но этот сценарий завершается Error: Cannot yield from finally in a force-closed generator. При обычном продолжении yield внутри finally возможен; при принудительном закрытии выдавать новое значение уже некому. Ошибочный сценарий проверяется отдельным subprocess-probe, а не предлагается как рабочая очистка.

<?php
$attempt = 0;
do {
    $attempt++;
    echo 'Попытка ', $attempt, "\n";
} while ($attempt < 2);

Попытка 1
Попытка 2

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

<?php
declare(strict_types=1);

$pages = [['A', 'B'], ['C'], []];
$pageNumber = 0;
do {
    $items = $pages[$pageNumber] ?? [];
    foreach ($items as $item) {
        echo $item, "\n";
    }
    $pageNumber++;
} while ($items !== [] && $pageNumber < 10);

A
B
C

Массив pages заменяет сетевой источник для воспроизводимого запуска. В настоящем API условие задаёт его договор: next, cursor или пустой ответ. Отдельно ограничивают число запросов, общий срок и повторяющийся cursor. Не делайте паузу после каждой страницы без причины: правила частоты разбираются в главе rate limits.

<?php
declare(strict_types=1);

$items = [
    ['sku' => 'A', 'active' => true],
    ['sku' => 'B', 'active' => false],
    ['sku' => 'C', 'active' => true],
];
foreach ($items as $item) {
    if (!$item['active']) {
        continue;
    }
    echo $item['sku'], "\n";
}

A
C

Continue переходит к следующей итерации. Если поставить break, после B цикл вообще закончится и C не будет обработан. Это разные решения задачи, а не взаимозаменяемые способы убрать одну строку.

<?php
declare(strict_types=1);

$warehouses = [['A', 'B'], ['C', 'D'], ['E']];
$found = null;
foreach ($warehouses as $warehouseNumber => $products) {
    foreach ($products as $sku) {
        if ($sku === 'C') {
            $found = $warehouseNumber;
            break 2;
        }
    }
}
echo 'Найдено на складе ', $found, "\n";

Найдено на складе 1

Число 2 означает выйти из двух охватывающих циклов. Для continue2 — перейти к следующей итерации внешнего. При усложнении структуры удобнее выделить функцию поиска и сделать return: число уровней не будет зависеть от добавленной вложенности. В switch continue без уровня ведёт себя как break и с PHP 7.3 предупреждает; внутри switch во внешнем цикле для его следующей итерации нужен continue2.

<?php $products = ['Чай', '<Кофе>']; ?>
<ul>
<?php foreach ($products as $product): ?>
<li><?= htmlspecialchars($product, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8') ?></li>
<?php endforeach; ?>
</ul>

<ul>
<li>Чай</li>
<li>&lt;Кофе&gt;</li>
</ul>

Текст между PHP-тегами отправляется как HTML. Короткий <?= — вывод выражения, но он сам не экранирует данные: htmlspecialchars нужен отдельно. Подобный синтаксис есть у if/elseif/else, while, for, foreach, switch и declare; для do…while используют обычные скобки. Этот пример можно выполнить в CLI, чтобы увидеть передаваемые браузеру байты.

<?php
declare(strict_types=1);

$settings = require __DIR__ . '/settings.php';
echo $settings['shop'], ': ', $settings['delivery'], "\n";

Мастерская: 250

В архив примера включён settings.php. Его return возвращает массив в выражение require; выполнение вызывающего файла затем продолжается. Если подключаемый файл обязателен, require явно выражает это требование.

<?php
declare(strict_types=1);

require_once __DIR__ . '/delivery.php';
require_once __DIR__ . '/delivery.php';
echo deliveryLabel(250), "\n";

Доставка: 250

Без once повторное объявление той же функции завершилось бы ошибкой. Once полезен для определения кода, но повторный require_once файла настроек не возвращает заново его массив: уже подключённый файл не исполняется. Для классов Composer предлагает загрузчик по имени; его устройство объясняется отдельно.

<?php
$skipImport = true;
if ($skipImport) {
    goto finished;
}
echo "Импорт\n";
finished:
echo "Сценарий закончен\n";

Сценарий закончен

Goto переносит управление на метку в допустимой области. Нельзя перескочить в другую функцию или войти внутрь цикла/switch извне. В обычном прикладном коде if, ранний return и функции чаще дают понятнее структуру. Здесь небольшой пример нужен, чтобы вы узнали конструкцию в старом проекте и могли заменить её осознанно.

<?php
declare(strict_types=1);

$orderId = 'ORD-42';
$parcelCount = 3;
if ($parcelCount < 1 || $parcelCount > 100) {
    throw new InvalidArgumentException('Нужно от 1 до 100 грузовых мест');
}
for ($parcel = 1; $parcel <= $parcelCount; $parcel++) {
    echo $orderId, '-', str_pad((string) $parcel, 2, '0', STR_PAD_LEFT),
        ' / ', $parcelCount, "\n";
}

ORD-42-01 / 3
ORD-42-02 / 3
ORD-42-03 / 3

Сначала задаётся номер 1, перед каждым проходом проверяется предел, после прохода номер увеличивается. В реальной форме parcelCount проверяют как число заданного диапазона: нельзя разрешить клиенту случайно заказать миллион итераций. Здесь генерируется текст этикеток; запросов в доставку и печати нет.

<?php
declare(strict_types=1);

function deliveryFee(string $method): int
{
    return match ($method) {
        'pickup' => 0,
        'courier' => 29900,
        'express' => 59900,
        default => throw new InvalidArgumentException('Неизвестный способ'),
    };
}
echo deliveryFee('courier'), "\n";
try {
    deliveryFee('teleport');
} catch (InvalidArgumentException $exception) {
    echo "Выберите способ доставки\n";
}

29900
Выберите способ доставки

Цена определяется на сервере по разрешенному коду, а не принимается из скрытого поля формы. Ошибка выбора отдельно от временной ошибки перевозчика.

<?php
declare(strict_types=1);

$rows = [['sku' => 'A', 'stock' => 2], ['sku' => 'B', 'stock' => -1], ['sku' => 'C', 'stock' => 0]];
$accepted = [];
$errors = [];
foreach ($rows as $index => $row) {
    if ($row['stock'] < 0) {
        $errors[] = 'Строка ' . ($index + 1);
        continue;
    }
    $accepted[$row['sku']] = $row['stock'];
}
echo json_encode($accepted, JSON_THROW_ON_ERROR), "\n";
echo implode(', ', $errors), "\n";

{"A":2,"C":0}
Строка 2

continue пропускает только текущую строку. break остановил бы весь импорт, return вышел бы из функции. В данном fixture форма строк уже известна; внешний CSV/JSON требует проверки каждого типа. Решение частично принять импорт должно быть согласовано, а не возникать случайно из continue.

<?php
$stocks = ['Чай' => 3, 'Кофе' => 2];
foreach ($stocks as &$stock) {
    $stock = $stock + 1;
}
unset($stock);
foreach (['Печенье' => 5, 'Сок' => 10] as $title => $stock) {
    echo 'Другой склад: ', $title, ' — ', $stock, ' уп.', "\n";
}
foreach ($stocks as $title => $stock) {
    echo 'Основной склад: ', $title, ' — ', $stock, ' уп.', "\n";
}

Другой склад: Печенье — 5 уп.
Другой склад: Сок — 10 уп.
Основной склад: Чай — 4 уп.
Основной склад: Кофе — 3 уп.

Остатки первого склада стали 4 и 3. unset удалил только связь местного имени с последней ячейкой. Второй цикл использовал имя stock для других чисел; итоговая ведомость показывает, что кофе не превратился в остаток сока 10.

<?php
declare(strict_types=1);

function collectShipments(array $pages): array
{
    $cursor = 'first';
    $seen = [];
    $result = [];
    $pageCount = 0;
    while ($cursor !== null) {
        if (++$pageCount > 10) {
            throw new LengthException('Превышен бюджет страниц');
        }
        if (isset($seen[$cursor])) {
            throw new UnexpectedValueException('Сервис повторил курсор');
        }
        $seen[$cursor] = true;
        $page = $pages[$cursor] ?? throw new UnexpectedValueException('Страница отсутствует');
        if (!is_array($page) || !is_array($page['items'] ?? null)
            || !array_is_list($page['items']) || count($page['items']) > 100
            || !array_key_exists('next', $page)
            || ($page['next'] !== null && (!is_string($page['next']) || $page['next'] === ''))) {
            throw new UnexpectedValueException('Неверный ответ страницы');
        }
        foreach ($page['items'] as $item) {
            if (!is_array($item) || !is_string($item['id'] ?? null)) {
                throw new UnexpectedValueException('Нет ID отправления');
            }
            $result[] = $item['id'];
        }
        $cursor = $page['next'];
    }
    return $result;
}
$pages = [
    'first' => ['items' => [['id' => 'S-1'], ['id' => 'S-2']], 'next' => 'page-2'],
    'page-2' => ['items' => [['id' => 'S-3']], 'next' => null],
];
echo implode(', ', collectShipments($pages)), "\n";
$pages['page-2']['next'] = 'first';
try { collectShipments($pages); }
catch (UnexpectedValueException $error) { echo $error->getMessage(), "\n"; }

S-1, S-2, S-3
Сервис повторил курсор

while управляет получением страниц, foreach — обработкой элементов внутри страницы: эти циклы работают вместе. Десять страниц по сто элементов ограничивают этот учебный результат тысячей элементов. При ошибке функция не выдаёт молча неполный список. У реального API отдельно ограничивают размер ответа, время, повтор запросов и проверяют его собственную схему курсора; нельзя подставлять этот договор в Bitrix без адаптации.