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

<?php
$sku = '002';
$quantity = 2;
$weightKg = 0.5;
echo 'Артикул: ', $sku, "\n";
echo 'Упаковок: ', $quantity, "\n";
echo 'Масса упаковки: ', $weightKg, ' кг', "\n";

Артикул: 002
Упаковок: 2
Масса упаковки: 0.5 кг

Кавычки делают 002 текстом. У 0.5 десятичный разделитель в PHP — точка. Мы не выводим массу как 0,5: форматирование для человека рассматривается отдельно. Такой вывод в консоль не требует HTML.

<?php
$quantity = 2;
$quantityText = '2';
echo 'Для человека: ', $quantity, ' и ', $quantityText, "\n";
var_dump($quantity);
var_dump($quantityText);

Для человека: 2 и 2
int(2)
string(1) "2"

int(2) — целое 2. string(1) "2" — строка длиной один байт. Цифра 1 здесь длина строки, а не её значение. var_dump не форматирует готовую карточку товара, зато помогает понять неожиданную операцию.

<?php
$isAvailable = false;
$customerNote = null;
if ($isAvailable) {
    echo "Можно заказать\n";
} else {
    echo "Сейчас нет в наличии\n";
}
if ($customerNote === null) {
    echo "Комментарий покупателя не указан\n";
}

Сейчас нет в наличии
Комментарий покупателя не указан

false — известный ответ о доступности. null — отсутствие комментария по принятому договору. Строка "false" была бы непустым текстом и дала бы другое поведение условия: тип нельзя угадывать по слову в кавычках.

<?php
var_dump(150);
var_dump('150');
var_dump(true);
var_dump(null);

int(150)
string(3) "150"
bool(true)
NULL

int — целое число; string(3) — строка длиной 3 байта; bool — логическое значение; NULL — отсутствие значения. У кириллицы число байтов не обязано совпадать с количеством букв. var_dump добавляет диагностическую запись, а не меняет переданное значение.

<?php
$value = 150;
echo 'Цена: ', $value, ' руб.; тип ', get_debug_type($value), "\n";
$value = 'Цена пока не указана';
echo 'Подпись: ', $value, '; тип ', get_debug_type($value), "\n";

Цена: 150 руб.; тип int
Подпись: Цена пока не указана; тип string

Первое значение — число 150, второе — текст. Присваивание заменило значение под тем же именем; get_debug_type возвращает название текущего типа как строку для echo. Оно не изменяет value. Так можно наблюдать динамическую типизацию, но для расчётов яснее отдельные price и label: фразу «Цена пока не указана» складывать с доставкой нельзя.

<?php
$comment = null;
if ($comment === null) {
    echo "Комментарий ещё не заполнен\n";
}
$comment = '';
if ($comment === '') {
    echo "Покупатель выбрал доставку без комментария\n";
}
$comment = 'Позвонить у подъезда';
if ($comment !== null && $comment !== '') {
    echo 'Курьеру: ', $comment, "\n";
}

Комментарий ещё не заполнен
Покупатель выбрал доставку без комментария
Курьеру: Позвонить у подъезда

Каждое присваивание задаёт отдельную учебную ситуацию. !== означает строгое неравенство, && требует обе проверки одновременно. Последняя строка выходит только для уже заданного непустого текста. Ноль и пустая строка не равны null при ===; не заменяйте это условие общей проверкой истинности.

<?php
$note = null;
if (!isset($note)) {
    echo "Указания для курьера нет\n";
}
$note = 'Позвонить заранее';
if (isset($note)) {
    echo 'Подпись на заказе: ', $note, "\n";
}
unset($note);
if (!isset($note)) {
    echo "Временная переменная удалена\n";
}

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

isset проверяет наличие имени с ненулевым значением, ! меняет ответ на противоположный. Поэтому первая и последняя проверки одинаково успешны, хотя сначала имя содержит null, а в конце имени уже нет. Вторая ветка использует реальный текст до удаления. unset не удаляет заказ или сохранённую запись из базы.

<?php
$isPaid = false;
echo $isPaid ? "Можно комплектовать\n" : "Ждём оплату\n";
$isPaid = true;
echo $isPaid ? "Можно комплектовать\n" : "Ждём оплату\n";

Ждём оплату
Можно комплектовать

Первый выбор получает false и возвращает вторую строку. После присваивания true второй выбор возвращает первую строку. Echo выводит готовую строку, а не само логическое значение. Внешняя платёжная система в этом примере не вызывается: присваивания позволяют безопасно воспроизвести два состояния.

<?php
$stock = 12;
$ordered = 3;
$remaining = $stock - $ordered;
echo 'Заказано: ', $ordered, ' шт.', "\n";
echo 'Осталось для продажи: ', $remaining, ' шт.', "\n";
$annualTarget = 1_000;
echo 'Годовой план: ', $annualTarget, ' шт.', "\n";

Заказано: 3 шт.
Осталось для продажи: 9 шт.
Годовой план: 1000 шт.

12 минус 3 даёт int 9. Он сохранён в remaining, поэтому доступен дальнейшему расчёту. Подчёркивание в литерале 1_000 помогает читать код и не входит в число или вывод; доступно с PHP 7.4. Его ставят только между цифрами, без удвоения. Отрицательное количество возврата можно записать как -3, но правила склада должны определить, где такой знак разрешён.

<?php
$items = 7;
$capacity = 3;
$fullBoxes = intdiv($items, $capacity);
$looseItems = $items % $capacity;
echo 'Полных коробок: ', $fullBoxes, "\n";
echo 'Банок отдельно: ', $looseItems, "\n";
echo 'Проверка комплектации: ', $fullBoxes * $capacity + $looseItems, "\n";
$exactShare = 6 / 3;
echo 'Точный результат 6 / 3: ', $exactShare, ' (', get_debug_type($exactShare), ')', "\n";
$average = 7 / 2;
echo 'Среднее на двух получателей: ', $average, ' (', get_debug_type($average), ')', "\n";

Полных коробок: 2
Банок отдельно: 1
Проверка комплектации: 7
Точный результат 6 / 3: 2 (int)
Среднее на двух получателей: 3.5 (float)

Возврат intdiv 2 используется как число полных коробок; остаток 1 нельзя потерять. У / результат int, если оба операнда целые и деление точное, иначе float. Дробное среднее не означает возможность отправить половину банки. Делитель должен быть ненулевым; intdiv(PHP_INT_MIN, -1) не помещается в int и вызывает ArithmeticError.

<?php
$unitWeightKg = 1.25;
$quantity = 2;
$packageWeightKg = 0.2;
$totalWeightKg = $unitWeightKg * $quantity + $packageWeightKg;
echo 'Товар: ', $unitWeightKg * $quantity, ' кг', "\n";
echo 'С упаковкой: ', $totalWeightKg, ' кг', "\n";
$gramsInBatch = 2.5e3;
echo 'Та же масса товара в граммах: ', $gramsInBatch, "\n";
echo 'Тип граммов: ', get_debug_type($gramsInBatch), "\n";

Товар: 2.5 кг
С упаковкой: 2.7 кг
Та же масса товара в граммах: 2500
Тип граммов: float

1.25 умножается на 2, затем к 2.5 прибавляется 0.2: в totalWeightKg лежит float для следующего выбора тарифа. 2.5e3 означает 2.5 × 1000 и остаётся float, хотя echo показывает 2500. Литерал 2500 без точки был бы int. Экранное представление 2.7 не означает точную десятичную арифметику внутри.

<?php
$temperature = 12.5;
if (is_finite($temperature)) {
    echo 'Температура: ', $temperature, ' °C', "\n";
}
$temperature = INF;
if (!is_finite($temperature)) {
    echo "Измерение отклонено: бесконечность\n";
}
$temperature = NAN;
if (is_nan($temperature)) {
    echo "Измерение отклонено: число не определено\n";
}
$temperature = -INF;
if (!is_finite($temperature)) {
    echo "Измерение отклонено: бесконечность\n";
}

Температура: 12.5 °C
Измерение отклонено: бесконечность
Измерение отклонено: число не определено
Измерение отклонено: бесконечность

Первое значение проходит проверку is_finite. NAN распознаётся отдельной функцией, потому что оно не равно даже самому себе, в том числе при ===. INF и -INF не проходят is_finite. Это проверка представления; допустимый диапазон температуры конкретного датчика нужно проверять дополнительно. Здесь нет JSON и внешнего устройства.

<?php
$raw = '012';
$quantity = (int) $raw;
echo 'Исходный текст: [', $raw, ']', "\n";
echo 'Количество для расчёта: ', $quantity, "\n";
echo 'За три одинаковые партии: ', $quantity * 3, "\n";
echo 'Опасный хвост 12items превращается в: ', (int) '12items', "\n";
echo 'Слово items превращается в: ', (int) 'items', "\n";
echo 'Дроби отсекаются к нулю: ', (int) 3.9, ', ', (int) -3.9, "\n";

Исходный текст: [012]
Количество для расчёта: 12
За три одинаковые партии: 36
Опасный хвост 12items превращается в: 12
Слово items превращается в: 0
Дроби отсекаются к нулю: 3, -3

В скобках (int) указано требуемое представление. Raw остаётся строкой 012, quantity получает int 12, который используется в умножении. Последние строки показывают предел преобразования: принятие числа PHP не подтверждает допустимость пользовательского текста. Для идентификатора 012 следует оставить строку, если ведущий ноль значим.

<?php
$quantity = '12';
$converted = settype($quantity, 'int');
if ($converted) {
    echo 'Тип количества после преобразования: ', get_debug_type($quantity), "\n";
    echo 'В двух партиях: ', $quantity * 2, ' шт.', "\n";
}

Тип количества после преобразования: int
В двух партиях: 24 шт.

Converted получил true, quantity стал int 12. Умножение использует quantity, а не converted: true не является преобразованным количеством. Когда не нужно менять входную переменную, отдельное присваивание $count = (int) $raw яснее сохраняет исходник. Допустимые type: boolean/bool, integer/int, float/double, string, array, object, null; неизвестное имя вызывает ValueError в PHP 8.

<?php
$raw = '12';
$stockAfterDelivery = $raw + 3;
$combinedCode = $raw . '3';
echo 'После поступления трёх штук: ', $stockAfterDelivery, "\n";
echo 'Код из двух текстовых частей: ', $combinedCode, "\n";
echo 'Исходное значение: ', $raw, ' (', get_debug_type($raw), ')', "\n";
if (12 == $raw) {
    echo "Значения равны после допустимого сравнения с преобразованием\n";
}
if (12 !== $raw) {
    echo "При строгом сравнении типы различаются\n";
}

После поступления трёх штук: 15
Код из двух текстовых частей: 123
Исходное значение: 12 (string)
Значения равны после допустимого сравнения с преобразованием
При строгом сравнении типы различаются

Плюс выбрал числовое действие и дал int 15; точка соединяет строки и дала string 123. Ни то, ни другое не переписало raw. == допускает преобразование по правилам сравнения, === требует одинаковый тип и значение, !== — отрицание строгого равенства. Не используйте арифметическое преобразование как проверку формата внешнего ввода.

<?php
$raw = 'false';
$enabled = (bool) $raw;
echo 'Текст [', $raw, '] после (bool): ', $enabled ? 'включено' : 'выключено', "\n";
$raw = '0';
echo 'Текст [0] после (bool): ', (bool) $raw ? 'включено' : 'выключено', "\n";
$raw = '';
echo 'Пустой текст после (bool): ', (bool) $raw ? 'включено' : 'выключено', "\n";
$selected = [];
echo 'Пустой выбор: ', (bool) $selected ? 'позиции выбраны' : 'позиций нет', "\n";
$selected = [0];
echo 'Выбор с кодом 0: ', (bool) $selected ? 'позиции выбраны' : 'позиций нет', "\n";

Текст [false] после (bool): включено
Текст [0] после (bool): выключено
Пустой текст после (bool): выключено
Пустой выбор: позиций нет
Выбор с кодом 0: позиции выбраны

Строка false содержит обычные буквы и даёт true. Исключения среди строк — пустая строка и ровно 0. У массива проверяется наличие элементов: [0] непустой, хотя единственное значение само по себе ложно. Исходный raw остаётся строкой; enabled — отдельный bool. Нулевой код может быть допустимым, поэтому значение элемента и наличие элемента — разные вопросы.

<?php
declare(strict_types=1);

function notificationSetting(string $raw): bool
{
    return match (strtolower(trim($raw))) {
        'true', '1' => true,
        'false', '0' => false,
        default => throw new InvalidArgumentException('Неизвестная настройка'),
    };
}
foreach (['false', ' TRUE ', 'maybe'] as $raw) {
    try {
        echo notificationSetting($raw) ? "Включено\n" : "Выключено\n";
    } catch (InvalidArgumentException $error) {
        echo $error->getMessage(), "\n";
    }
}

Выключено
Включено
Неизвестная настройка

Функция сначала нормализует пробелы и регистр, затем принимает только согласованные варианты. Альтернатива — FILTER_VALIDATE_BOOLEAN с FILTER_NULL_ON_FAILURE, если его набор допустимых слов подходит вашему протоколу. Неизвестное значение не превращается молча в false.

<?php
echo 26, ' ', 0b11010, ' ', 0o32, ' ', 0x1A, "\n";
echo 1_000_000, "\n";
echo intdiv(17, 5), ' коробки, остаток ', 17 % 5, "\n";

26 26 26 26
1000000
3 коробки, остаток 2

0b — двоичная запись, 0o — восьмеричная (PHP 8.1+), 0x — шестнадцатеричная; подчёркивания помогают читать литерал и не входят в число. В старой восьмеричной записи 032 — тоже26: не добавляйте ведущий ноль к десятичным литералам. intdiv возвращает целую часть частного, % — остаток.

<?php
function addNonNegative(int $current, int $incoming): int {
    if ($current < 0 || $incoming < 0 || $current > PHP_INT_MAX - $incoming) {
        throw new OverflowException('Сумма выходит за допустимый диапазон');
    }
    return $current + $incoming;
}
$stock = 120;
$stock = addNonNegative($stock, 30);
echo 'После поставки: ', $stock, ' шт.', "\n";
try {
    $stock = addNonNegative(PHP_INT_MAX, 1);
} catch (OverflowException $error) {
    echo 'Поставка отклонена: ', $error->getMessage(), "\n";
}
echo 'Последний допустимый остаток: ', $stock, ' шт.', "\n";

После поставки: 150 шт.
Поставка отклонена: Сумма выходит за допустимый диапазон
Последний допустимый остаток: 150 шт.

Первый вызов получает current120/incoming30, возвращает int150 в правую часть присваивания, stock становится150. Во втором опытном вызове проверяется предельная пара PHP_INT_MAX/1. До return дело не доходит: catch получает отказ, присваивание stock не завершилось, поэтому в нём остаётся150. Эта граница работает на поддерживаемой 32- или 64-битной платформе; конкретное максимальное число в ожидаемый вывод не зашито.

<?php
$measuredKg = 0.1 + 0.2;
$expectedKg = 0.3;
$toleranceKg = 0.000001;
echo 'Измерено: ', number_format($measuredKg, 3, '.', ''), ' кг', "\n";
echo 'Ожидается: ', number_format($expectedKg, 3, '.', ''), ' кг', "\n";
if ($measuredKg !== $expectedKg) { echo "Точное двоичное значение отличается\n"; }
$differenceKg = abs($measuredKg - $expectedKg);
if ($differenceKg <= $toleranceKg) {
    echo "Масса принята: отклонение укладывается в допуск\n";
}

Измерено: 0.300 кг
Ожидается: 0.300 кг
Точное двоичное значение отличается
Масса принята: отклонение укладывается в допуск

Оба значения выглядят как0.300 после округления для экрана, но === сравнивает хранимые числа. Abs возвращает положительный модуль разницы; сравнение с допуском даёт true и выбирает приёмку. Допуск задан в килограммах и выбран только для опыта. Number_format возвращает строку с тремя десятичными знаками и не исправляет внутреннее float. Измерения реального прибора требуют его диапазона, единиц и точности.

<?php
declare(strict_types=1);

function sensorValue(float $value): string
{
    if (!is_finite($value)) {
        throw new InvalidArgumentException('Показание не является конечным числом');
    }
    return number_format($value, 1, '.', '');
}
foreach ([21.25, INF, NAN] as $value) {
    try {
        echo sensorValue($value), "\n";
    } catch (InvalidArgumentException $error) {
        echo $error->getMessage(), "\n";
    }
}

21.3
Показание не является конечным числом
Показание не является конечным числом

INF и NAN — специальные float-значения. NAN нельзя надёжно искать обычным сравнением с самим собой; используйте is_nan, а для допустимого конечного числа — is_finite. Перед записью в JSON отдельно проверяйте ограничения формата. Деньги с фиксированными младшими единицами храните int или используйте согласованную десятичную арифметику.

<?php
$expected = 1000000.0;
$measured = 1000000.2;
$absoluteTolerance = 0.01;
$relativeTolerance = 0.000001;
$allowedDifference = max($absoluteTolerance, abs($expected) * $relativeTolerance);
echo 'Разрешённое отклонение: ', number_format($allowedDifference, 2, '.', ''), "\n";
echo 'Полученное отклонение: ', number_format(abs($measured - $expected), 2, '.', ''), "\n";
if (abs($measured - $expected) <= $allowedDifference) {
    echo "Показание принято по согласованному допуску\n";
}

Разрешённое отклонение: 1.00
Полученное отклонение: 0.20
Показание принято по согласованному допуску

Относительная часть равна1000000×0.000001=1. Max выбирает большее из1 и абсолютного минимума0.01. Разница около0.2 укладывается в1. У ожидаемого нуля останется абсолютный допуск0.01. Это конкретный договор сравнения с опорным expected, а не универсальная замена ===: для разных задач выбирают другую формулу и проверяют конечность входов.

<?php
$raw = '1e2';
if (is_numeric($raw)) {
    echo 'Числовая форма [', $raw, '] даёт в расчёте ', $raw + 0, "\n";
}
$raw = '12';
echo 'После поступления трёх штук: ', $raw + 3, ' шт.', "\n";
$damaged = '12units';
echo 'Явный (int) отбросил хвост и получил: ', (int) $damaged, "\n";
try {
    $total = 'units' + 3;
} catch (TypeError $error) {
    echo "Расчёт не выполнен: слово нельзя сложить с числом\n";
}

Числовая форма [1e2] даёт в расчёте 100
После поступления трёх штук: 15 шт.
Явный (int) отбросил хвост и получил: 12
Расчёт не выполнен: слово нельзя сложить с числом

1e2 означает1×10² и подходит is_numeric, но наш магазин не обязан принимать такой ввод количества. Строка12 в сложении даёт15. Явное приведение12units даёт12 без подтверждения допустимого формата; исходный damaged при этом не исправлен. Нечисловое слово вызывает TypeError, поэтому значение total в этом пути не получено.

<?php
function quantityFromText(string $text): int {
    if (preg_match('/\A[1-9][0-9]?\z/', $text) !== 1) {
        throw new InvalidArgumentException('Нужно целое от 1 до 99');
    }
    return (int) $text;
}
$unitPrice = 150;
foreach (['12', '1e2', '0012', '12units'] as $text) {
    try {
        $quantity = quantityFromText($text);
        echo '[', $text, ']: ', $quantity, ' шт., к оплате ', $quantity * $unitPrice, ' руб.', "\n";
    } catch (InvalidArgumentException $error) {
        echo '[', $text, ']: заказ не рассчитан — ', $error->getMessage(), "\n";
    }
}

[12]: 12 шт., к оплате 1800 руб.
[1e2]: заказ не рассчитан — Нужно целое от 1 до 99
[0012]: заказ не рассчитан — Нужно целое от 1 до 99
[12units]: заказ не рассчитан — Нужно целое от 1 до 99

Foreach по очереди даёт четыре текста. Только12 целиком совпадает: функция возвращает int12 в quantity, вызывающий код умножает12×150 и печатает1800. На остальных входах throw прерывает расчёт этой строки, catch показывает конкретный исходный текст и причину; следующая итерация продолжается. Внешнее поле до вызова ещё проверяют на is_string: этот пример уже задаёт четыре строки сам. Разрешение пробелов или ведущих нулей потребует явного изменения договора.

<?php
declare(strict_types=1);
function boxTotal(int $boxes): int {
    return $boxes * 6;
}
$units = boxTotal(3);
echo 'Три коробки содержат ', $units, ' банок', "\n";
try {
    $units = boxTotal('3');
} catch (TypeError $error) {
    echo "Текстовое количество отклонено до расчёта\n";
}
echo 'Последний рассчитанный итог: ', $units, ' банок', "\n";

Три коробки содержат 18 банок
Текстовое количество отклонено до расчёта
Последний рассчитанный итог: 18 банок

Вызов с int3 создаёт местный boxes3; тело получает18; return после проверки int отдаёт18 в units. Строка3 во втором вызове отвергается на входе из строгого файла: тело вообще не выполняется, новое присваивание units не завершается. Старое18 сохранено. Тип int ещё допускает отрицательные числа: проверка диапазона количества — отдельное правило задачи.

<?php
declare(strict_types=1);

function commentLabel(?string $comment): string
{
    if ($comment === null) {
        return 'Не запрашивали';
    }
    return $comment === '' ? 'Оставлено пустым' : $comment;
}
echo commentLabel(null), "\n";
echo commentLabel(''), "\n";
echo commentLabel('Позвонить'), "\n";

Не запрашивали
Оставлено пустым
Позвонить

?string разрешает null, но не делает аргумент необязательным. Для пропуска нужен default, например ?string $comment = null. В PHP 8.4 неявная nullable-запись string $comment = null устарела: отсутствие указывается в типе явно.

<?php
declare(strict_types=1);

function skuFromInput(mixed $raw): string
{
    if (!is_string($raw) || $raw === '') {
        throw new InvalidArgumentException('Нужен непустой артикул');
    }
    return $raw;
}
foreach (['0012', 12, null] as $raw) {
    try {
        echo skuFromInput($raw), "\n";
    } catch (InvalidArgumentException $error) {
        echo "Неверный артикул\n";
    }
}

0012
Неверный артикул
Неверный артикул

Неизвестный тип принимается намеренно, затем сужается проверкой. mixed не объединяют с другими типами: они уже в него входят. Литеральные true, false и null можно объявлять самостоятельно начиная с PHP 8.2; они полезны для точного договора, но обычный переключатель чаще имеет тип bool.

<?php
function showStatus(string $text): void {
    echo $text, "\n";
}
$result = showStatus('Заказ 41: комплектуется');
echo 'Значение вызова для наблюдения: ';
var_dump($result);
echo "Можно напечатать следующую строку отчёта\n";

Заказ 41: комплектуется
Значение вызова для наблюдения: NULL
Можно напечатать следующую строку отчёта

Строка из аргумента попадает в местный text. Echo внутри сразу отправляет её в вывод. Завершение функции возвращает управление к месту вызова; наблюдаемое значение — null, а не текст статуса. Следующий echo выполняется. У void разрешён пустой return; для раннего выхода, но return с выражением запрещён.

<?php
function rejectOrder(): never {
    throw new DomainException('Нет остатка');
}
try {
    rejectOrder();
    echo "Заказ можно выдать\n";
} catch (DomainException $error) {
    echo 'Заказ отклонён: ', $error->getMessage(), "\n";
}
echo "Переходим к следующей проверке\n";

Заказ отклонён: Нет остатка
Переходим к следующей проверке

RejectOrder не возвращается обычным путём; выполнение перескакивает в ближайший подходящий catch. Строка о выдаче пропущена. После catch программа продолжается, что видно в последней строке. Never доступен с PHP8.1 и запрещает любой return; выход из процесса и бесконечное выполнение — другие способы не вернуться, но здесь использовано исключение.

<?php
declare(strict_types=1);

function totalUnits(iterable $counts): int
{
    $total = 0;
    foreach ($counts as $count) {
        if (!is_int($count) || $count < 0) {
            throw new InvalidArgumentException('Нужно целое количество');
        }
        $total += $count;
    }
    return $total;
}
echo totalUnits([2, 3]), "\n";
echo totalUnits(new ArrayIterator([4, 5])), "\n";

5
9

Iterable гарантирует возможность перебора, но не тип каждого элемента и не возможность повторного прохода. Например, генератор может быть одноразовым. Поэтому проверка count остаётся внутри расчёта. Объекты ArrayIterator и генераторы подробно объясняются в главе об итераторах.

<?php
declare(strict_types=1);

$stream = fopen('php://memory', 'w+b');
if ($stream === false) {
    throw new RuntimeException('Не удалось открыть поток');
}
try {
    var_dump(is_resource($stream));
    fwrite($stream, 'SKU-17');
    rewind($stream);
    echo stream_get_contents($stream), "\n";
} finally {
    fclose($stream);
}
var_dump(is_resource($stream));

bool(true)
SKU-17
bool(false)

Ресурс — выданный PHP доступ к внешнему или внутреннему механизму, например открытому потоку. Это не содержимое файла. После fclose такой доступ закрыт. Некоторые расширения в современных версиях используют специальные объекты вместо ресурсов; проверяйте контракт конкретной функции.

<?php
declare(strict_types=1);

function batchSize((Countable&Traversable)|null $batch): int
{
    return $batch === null ? 0 : count($batch);
}
echo batchSize(new ArrayIterator(['A', 'B'])), "\n";
echo batchSize(null), "\n";
try {
    batchSize(['A', 'B']);
} catch (TypeError $error) {
    echo "Массив не является требуемым объектом\n";
}

2
0
Массив не является требуемым объектом

Countable и Traversable — имена интерфейсов. Знак & требует оба, |null допускает отсутствие, скобки отделяют пересечение. Это DNF-тип(PHP 8.2+). Массив можно пересчитать и обойти, но он не реализует интерфейсы объектов. Если реально нужно поддержать массив, добавьте его в договор или выберите iterable и иной способ подсчёта. Новичку достаточно вернуться к этому примеру после интерфейсов.

<?php
declare(strict_types=1);

function parseQuantity(mixed $raw): int
{
    if (!is_string($raw) || preg_match('/\A[1-9][0-9]{0,2}\z/', $raw) !== 1) {
        throw new InvalidArgumentException('Количество: целое от1 до999');
    }

    return (int) $raw;
}
foreach (['12', '0', '12товаров', ['12']] as $raw) {
    try {
        echo parseQuantity($raw), "\n";
    } catch (InvalidArgumentException $exception) {
        echo "Некорректно\n";
    }
}

12
Некорректно
Некорректно
Некорректно

Сначала проверяется тип: пользователь может отправить quantity[]=12. Затем ограниченная грамматика и диапазон. Здесь ведущие нули намеренно запрещены контрактом. Числовое приведение происходит только после проверки, поэтому "12 товаров" не станет заказом из 12 штук.

<?php
declare(strict_types=1);

$subtotalKopecks = 19990 * 3;
$discountPercent = 10;
// Для этого магазина дробная копейка скидки отбрасывается.
$discountKopecks = intdiv($subtotalKopecks * $discountPercent, 100);
echo $subtotalKopecks - $discountKopecks, "\n";
echo ((0.1 + 0.2) === 0.3) ? "равно\n" : "не строго равно\n";

53973
не строго равно

Это демонстрация одной объявленной политики округления, не универсальное правило бухгалтерии. Проверьте ограничения суммы, чтобы произведение не вышло за PHP_INT_MAX. Для десятичных расчетов сложной финансовой области выбирают decimal/BCMath и согласованную точность. float уместен для измерений с допуском.

<?php
$row = ['name' => 'Чай', 'sizes' => ['small', 'large']];
$product = (object) $row;
echo $product->name, "\n";
var_dump(is_array($product->sizes));
$again = (object) $product;
var_dump($again === $product);

Чай
bool(true)
bool(true)

Получился объект встроенного класса stdClass. Ключи массива стали именами свойств, а sizes остался массивом. Каст уже существующего объекта в object не клонирует его. === подтверждает, что это тот же экземпляр, поэтому изменение его свойств видно через обе переменные.

<?php
$empty = (object) null;
var_dump(get_object_vars($empty));
$label = (object) 'SKU-12';
echo $label->scalar, "\n";
$numeric = (object) [12 => 'Двенадцать'];
echo $numeric->{'12'}, "\n";

array(0) {
}
SKU-12
Двенадцать

get_object_vars здесь получает публичные свойства простого stdClass. Числовое имя свойства читается через фигурные скобки и строку. Преобразование произвольного слова в объект со свойством scalar почти никогда не создаёт полезную предметную модель: лучше явно назвать необходимые данные.

<?php
interface NoticeSender
{
    public function send(string $message): void;
}
class ScreenSender implements NoticeSender
{
    public function send(string $message): void
    {
        echo $message, "\n";
    }
}
class UnrelatedSender
{
    public function send(string $message): void
    {
        echo $message, "\n";
    }
}
function notify(NoticeSender $sender): void
{
    $sender->send('Заказ готов');
}
notify(new ScreenSender());
try {
    notify(new UnrelatedSender());
} catch (TypeError $error) {
    echo "Нет объявленного договора NoticeSender\n";
}

Заказ готов
Нет объявленного договора NoticeSender

public означает доступность метода вызывающему коду, : void — отсутствие полезного результата. Одинаковое тело send у двух классов не заменило implements. Это помогает связать части сервиса через явный договор, который проверяется PHP.

<?php
class CatalogItem
{
    public function __construct(public string $name) {}
}
class Product extends CatalogItem
{
    public function productLabel(self $item): string
    {
        return 'self: ' . $item->name;
    }
    public function catalogLabel(parent $item): string
    {
        return 'parent: ' . $item->name;
    }
}
$product = new Product('Чай');
$category = new CatalogItem('Категория напитков');
echo $product->productLabel($product), "\n";
echo $product->catalogLabel($category), "\n";
echo $product->catalogLabel($product), "\n";
try {
    $product->productLabel($category);
} catch (TypeError $error) {
    echo "Категория не является Product\n";
}

self: Чай
parent: Категория напитков
parent: Чай
Категория не является Product

Внутри Product имя self обозначает Product, поэтому обычный CatalogItem отклонён. parent обозначает CatalogItem; экземпляр Product тоже подходит, потому что наследуется от CatalogItem. Имена параметров item локальны для каждого вызова, стрелка читает публичное свойство name.

<?php
class ExportJob
{
    public static function fromDefinition(): self
    {
        return new self();
    }
    public static function fromCalledClass(): static
    {
        return new static();
    }
}
class CsvExportJob extends ExportJob {}
echo get_class(CsvExportJob::fromDefinition()), "\n";
echo get_class(CsvExportJob::fromCalledClass()), "\n";

ExportJob
CsvExportJob

Метод унаследован и оба раза вызван через CsvExportJob. new self создаёт класс места объявления — ExportJob. new static учитывает позднее статическое связывание и создаёт CsvExportJob; тип результата static обещает это вызывающему коду. Пример намеренно использует пустые конструкторы: если потомок потребует другие обязательные аргументы, универсальная фабрика new static() перестанет быть корректной.

<?php
$stream = fopen('php://memory', 'w+b');
if ($stream === false) {
    throw new RuntimeException('Не удалось открыть поток');
}
fwrite($stream, "Заказ 12: упакован\n");
rewind($stream);
$sameStream = $stream;
$report = stream_get_contents($sameStream);
if ($report === false) {
    throw new RuntimeException('Не удалось прочитать отчёт');
}
echo $report;
fclose($stream);
if (!is_resource($sameStream)) {
    echo "Повторное чтение запрещено: доступ уже закрыт\n";
}
echo 'Оставшееся значение: ', get_debug_type($sameStream), "\n";

Заказ 12: упакован
Повторное чтение запрещено: доступ уже закрыт
Оставшееся значение: resource (closed)

Fwrite получает ресурс и строку и возвращает число записанных байтов или false; здесь маленький текст пишется в локальную память. Rewind возвращает указатель к началу; stream_get_contents возвращает оставшиеся байты как строку или false. Report получает текст, echo его выводит. SameStream не открыл второй поток: fclose закрывает общий доступ. На диске отчёт не сохраняется. В производственном потоке проверяют успех записи/rewind и обеспечивают закрытие через finally.

<?php
$normalize = strtoupper(...);
echo get_debug_type($normalize), "\n";
echo $normalize('tea-12'), "\n";

Closure
TEA-12

Многоточие внутри этих скобок — специальный синтаксис создания first-class callable в PHP 8.1+, а не пропущенный фрагмент учебника и не распаковка массива. Первая строка не вызывает strtoupper для строки; она создаёт Closure. Вторая форма скобок с tea-12 уже вызывает сохранённое действие.

<?php
function prepareCode(string $code, callable $normalize): string
{
    return $normalize($code);
}
echo prepareCode(' tea-12 ', trim(...)), "\n";
echo prepareCode('tea-12', strtoupper(...)), "\n";

tea-12
TEA-12

callable гарантирует возможность вызова в данном контексте, но не описывает число, типы аргументов и смысл результата для каждого обработчика. Наш договор дополнительно требует действие string → string. Если нужно одновременно обрезать пробелы и изменить регистр, передайте функцию, которая явно делает оба шага.

<?php
class CodePrefix
{
    public function add(string $code): string
    {
        return 'SHOP-' . $code;
    }
    public function __invoke(string $code): string
    {
        return $this->add($code);
    }
}
$prefix = new CodePrefix();
$method = [$prefix, 'add'];
echo $method('12'), "\n";
echo $prefix('13'), "\n";
var_dump(is_callable([CodePrefix::class, 'add']));

SHOP-12
SHOP-13
bool(false)

add — нестатический метод: ему нужен экземпляр. Начиная с PHP 8 нельзя выдавать такую пару имя класса + нестатический метод за допустимый статический callback. __invoke делает сам объект вызываемым; $this обозначает текущий экземпляр.

<?php
function confirmPrepared(bool $prepared): true
{
    if (!$prepared) {
        throw new LogicException('Сначала подготовьте данные');
    }
    return true;
}
$confirmed = confirmPrepared(true);
if ($confirmed) {
    echo "Данные готовы: можно показывать кнопку печати\n";
}
try {
    confirmPrepared(false);
} catch (LogicException $error) {
    echo 'Кнопка недоступна: ', $error->getMessage(), "\n";
}

Данные готовы: можно показывать кнопку печати
Кнопка недоступна: Сначала подготовьте данные

Первый вызов возвращает true в confirmed, и условие выбирает дальнейшее сообщение. Второй вызов останавливается на throw и до return не доходит; catch выводит причину. Тип true разрешён с PHP 8.2; одиночный false тоже с 8.2, false в union — с 8.0. True|false записывают как bool. Если подтверждение не требуется, часто достаточно void.

<?php
function orderIdLabel(int|string $value): string {
    return 'Заказ ' . $value;
}
function legacyRowLimit(int|bool $value): int {
    return is_int($value) ? $value : ($value ? 100 : 0);
}
function packedWeight(int|float $kg): float {
    return $kg + 0.2;
}
echo orderIdLabel('0012'), "\n";
echo 'Лимит из текста 12: ', legacyRowLimit('12'), ' строк', "\n";
echo 'Лимит из текста no: ', legacyRowLimit('no'), ' строк', "\n";
echo 'Посылка: ', packedWeight('12.5'), ' кг', "\n";

Заказ 0012
Лимит из текста 12: 12 строк
Лимит из текста no: 100 строк
Посылка: 12.7 кг

Этот файл намеренно нестрогий. У orderIdLabel исходный string уже разрешён: ведущие нули остаются в подписи. У legacyRowLimit строка12 преобразуется в int12, и функция возвращает этот лимит. Слово no не годится для int, зато превращается в booltrue: старый договор трактует его как100 строк, хотя человек мог ожидать запрет. У packedWeight строка12.5 выбирает float, тело добавляет упаковку0.2 и возвращает12.7 в echo. Такие перегруженные договоры показаны для чтения старого API; новый текстовый ввод лучше разбирать явно.

<?php
require __DIR__ . '/price.php';
echo packagePrice('2'), "\n";

300

price.php содержит strict_types=1 и объявление int $boxes, но место вызова в example.php работает в слабом режиме. Строка 2 допускает преобразование в int. В ZIP лежат оба файла.

<?php
declare(strict_types=1);
require __DIR__ . '/price.php';
try {
    echo packagePrice('2'), "\n";
} catch (TypeError $error) {
    echo "Строка вместо int отклонена\n";
}

Строка вместо int отклонена

Теперь strict_types=1 стоит именно перед вызовом. Библиотека при этом может не объявлять строгий режим. В обоих случаях правила самой арифметики и явных кастов не превратились в другую разновидность PHP.

<?php
declare(strict_types=1);
require __DIR__ . '/weak-return.php';
require __DIR__ . '/strict-return.php';
$total = weakTotal();
echo 'Слабая библиотека: ', $total, ' руб., тип ', get_debug_type($total), "\n";
try {
    $total = strictTotal();
} catch (TypeError $error) {
    echo "Строгая библиотека: строка не прошла договор результата int\n";
}
echo 'Последний пригодный итог: ', $total, ' руб.', "\n";

Слабая библиотека: 300 руб., тип int
Строгая библиотека: строка не прошла договор результата int
Последний пригодный итог: 300 руб.

В обеих функциях литерал300 намеренно написан в кавычках. В weakTotal возвращаемая числовая строка допускает преобразование в int300; вызывающий код использует его как сумму. StrictTotal объявлена в строгом файле и выдаёт TypeError до возврата в присваивание. Тело нужно исправить на числовой расчёт или правильный договор; catch здесь позволяет увидеть оба пути. Ни один из файлов не получает случайное текущее состояние окружения.

<?php
declare(strict_types=1);
function orderTotal(int $goods): int {
    $deliveryText = '50';
    return $goods + $deliveryText;
}
$total = orderTotal(300);
echo 'Товары и доставка: ', $total, ' руб.', "\n";

Товары и доставка: 350 руб.

На входе int300 соответствует параметру. Затем + использует числовой контекст: строка50 участвует как число, получается int350. Выходной договор int тоже выполнен. Strict_types не запрещает это преобразование внутри выражения. Для внешнего deliveryText нужна явная проверка до расчёта; в опыте литерал заранее известен.