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

<?php
$unitPrice = 150;
$quantity = 2;
$delivery = 50;
$itemsTotal = $unitPrice * $quantity;
$payable = $itemsTotal + $delivery;
echo 'Товары: ', $itemsTotal, ' руб.', "\n";
echo 'Доставка: ', $delivery, ' руб.', "\n";
echo 'К оплате: ', $payable, ' руб.', "\n";

Товары: 300 руб.
Доставка: 50 руб.
К оплате: 350 руб.

Справа от каждого = сначала вычисляется выражение. Оно даёт одно значение; затем значение сохраняется слева. Цены намеренно целые. Для обычных сумм с копейками договор единиц требуется уточнить, например хранить 15000 копеек.

<?php
$stock = 3;
$quantity = 2;
$canOrder = $quantity > 0 && $stock >= $quantity;
if ($canOrder) {
    echo 'Можно заказать: ', $quantity, ' уп.', "\n";
} else {
    echo "Проверьте количество и остаток\n";
}

Можно заказать: 2 уп.

2 > 0 даёт true; 3 >= 2 тоже true; && даёт true. В canOrder хранится логический ответ, а человеку показано понятное действие. Если quantity станет 4, сработает вторая ветвь. Входы здесь заранее целые: && не заменяет проверку типа внешней формы.

<?php
$unitPrice = 150;
$quantity = 2;
$discountPerItem = 20;
$discountPerOrder = 20;
$byItem = ($unitPrice - $discountPerItem) * $quantity;
$byOrder = $unitPrice * $quantity - $discountPerOrder;
echo 'Скидка с каждой упаковки: ', $byItem, ' руб.', "\n";
echo 'Скидка один раз с заказа: ', $byOrder, ' руб.', "\n";

Скидка с каждой упаковки: 260 руб.
Скидка один раз с заказа: 280 руб.

Скобки в первой формуле объединяют цену и скидку до умножения: 130 × 2. Во второй сначала получаем 300, затем вычитаем 20 один раз. Правильность выбирается по требованию магазина, а не по тому, какая формула короче.

<?php
$quantity = 2;
$price = 150;
$delivery = 40;
$subtotal = $quantity * $price;
$total = $subtotal + $delivery;
echo 'Товар: ', $quantity, ' × ', $price, ' = ', $subtotal, ' руб.', "\n";
echo 'Доставка: ', $delivery, ' руб.', "\n";
echo 'К оплате: ', $total, ' руб.', "\n";

Товар: 2 × 150 = 300 руб.
Доставка: 40 руб.
К оплате: 340 руб.

Сначала справа от каждого = вычисляется значение, затем сохраняется слева. Subtotal получает 300, total получает 340. Echo читает эти числа и подписи. Запись $total=($quantity*$price)+$delivery дала бы тот же итог, но отдельный subtotal полезен как самостоятельная строка чека и при проверке расчёта. Цены в этом примере заранее заданы целыми рублями.

<?php
$original = $current = 5;
$current -= 2;
echo 'Было на складе: ', $original, "\n";
echo 'Зарезервировано: ', $original - $current, "\n";
echo 'Доступно сейчас: ', $current, "\n";

Было на складе: 5
Зарезервировано: 2
Доступно сейчас: 3

Присваивание current=5 отдаёт число 5 в original. Затем -=2 сохраняет 3 только в current; original остаётся 5. Это независимые целочисленные значения, связи по ссылке нет. Разница 5−3=2 используется в строке резерва. Понятный развёрнутый эквивалент начала: $current=5; затем $original=$current;.

<?php
$cartTotal = 300;
$receiptTotal = ($cartTotal += 40);
echo 'Сумма выданного чека: ', $receiptTotal, ' руб.', "\n";
$cartTotal += 100;
echo 'Корзина после нового товара: ', $cartTotal, ' руб.', "\n";
echo 'Прежний чек по-прежнему: ', $receiptTotal, ' руб.', "\n";

Сумма выданного чека: 340 руб.
Корзина после нового товара: 440 руб.
Прежний чек по-прежнему: 340 руб.

В скобках += читает 300, добавляет 40, сохраняет 340 в cartTotal и отдаёт 340 внешнему присваиванию receiptTotal. Позднее cartTotal меняется на 440, снимок receiptTotal остаётся 340. Так видно и изменение состояния, и возвращённое значение. В рабочем расчёте те же действия можно записать двумя строками: $cartTotal+=40; $receiptTotal=$cartTotal;.

<?php
function packingCost($boxes) {
    return $boxes * 20;
}
$goodsTotal = 300;
$packing = packingCost(2);
$orderTotal = $goodsTotal + $packing;
echo 'Упаковка: ', $packing, ' руб.', "\n";
echo 'Заказ: ', $orderTotal, ' руб.', "\n";
echo 'Тот же итог одним выражением: ', $goodsTotal + packingCost(2), ' руб.', "\n";

Упаковка: 40 руб.
Заказ: 340 руб.
Тот же итог одним выражением: 340 руб.

В packingCost(2) число 2 становится местным boxes. Умножение даёт 40, return завершает вызов и отдаёт 40 в выражение справа от =, затем packing получает 40. В последнем echo второй самостоятельный вызов возвращает ещё одно 40 прямо в сложение с 300. Вся сумма 340 поступает в вывод. Это два вызова с одинаковыми входами и результатом; первый результат сам по себе повторно не используется во втором вызове.

<?php
function parcelLabel($number) {
    return 'Посылка №' . $number;
}
$nextNumber = 10;
$firstLabel = parcelLabel($nextNumber++);
echo $firstLabel, "\n";
echo 'Следующий номер после вызова: ', $nextNumber, "\n";
$nextNumber = 10;
$secondLabel = parcelLabel(++$nextNumber);
echo $secondLabel, "\n";
echo 'Номер после второго вызова: ', $nextNumber, "\n";

Посылка №10
Следующий номер после вызова: 11
Посылка №11
Номер после второго вызова: 11

В первом вызове аргумент выражения nextNumber++ равен 10: местный number получает 10, return возвращает строку в firstLabel. Внешний счётчик уже увеличен до 11. Затем мы намеренно начинаем независимое сравнение снова с 10; ++nextNumber даёт 11 и параметр второго вызова получает 11. Это не две последовательные выдачи номеров одного склада, а сравнение двух форм на одинаковом старте. Для последовательной выдачи 10 и 11 используйте два вызова с постфиксной формой без сброса.

<?php
$goodsTotal = 1200;
$freeDeliveryFrom = 1000;
$delivery = $goodsTotal >= $freeDeliveryFrom ? 0 : 150;
$total = $goodsTotal + $delivery;
echo 'Товары: ', $goodsTotal, ' руб.', "\n";
echo 'Доставка: ', $delivery, ' руб.', "\n";
echo 'К оплате: ', $total, ' руб.', "\n";

Товары: 1200 руб.
Доставка: 0 руб.
К оплате: 1200 руб.

Сравнение 1200>=1000 возвращает true. Выбирается выражение 0 после ?, и присваивание сохраняет 0 в delivery. Сложение использует это число: 1200+0=1200. Если заменить goodsTotal на 800, условие станет false, delivery будет 150, итог — 950. Нулевую выбранную цену нельзя затем заменить через ?: на 150: это снова сделало бы бесплатную доставку платной.

<?php
$quantity = 2;
$unitPrice = 150;
$line = [
    'title' => 'Чай',
    'quantity' => $quantity,
    'total' => $quantity * $unitPrice,
];
echo $line['title'], ': ', $line['quantity'], ' шт., ', $line['total'], ' руб.', "\n";

Чай: 2 шт., 300 руб.

Квадратные скобки создают массив; => связывает ключ с вычисленным значением. Quantity получает прочитанное 2, total — результат 2×150=300. Само выражение массива становится значением line. В echo три обращения по ключам получают строку Чай и числа 2/300. Изменение внешнего quantity после построения не пересчитает line автоматически. New создаёт объект как значение выражения; это следующая отдельная ступень после массивов в главе объектов.

<?php
echo 30 - 8 - 2, "\n";
echo 30 - (8 - 2), "\n";
echo 2 ** 3 ** 2, "\n";
echo (2 ** 3) ** 2, "\n";
echo -3 ** 2, "\n";
echo (-3) ** 2, "\n";

20
24
512
64
-9
9

Степень связывается сильнее унарного минуса, поэтому -3 ** 2 означает -(3 ** 2). В математическом условии задачи обязательно уточняйте, возводится в степень отрицательное число или меняется знак результата.

<?php
$quantity = 4;
var_dump(1 <= $quantity <= 10);

Намеренно неверный синтаксис: unexpected token "<=". Разделите проверки оператором &&. Одних скобок вокруг уже полученного bool недостаточно для проверки диапазона.

<?php
$position = 2;
$result = $position + $position++;
// Не закладывайте конкретный результат в бизнес-правило.

Это синтаксически допустимый, но намеренно неисполняемый образец неудачной конструкции. Приоритет не фиксирует общий порядок чтения $position и побочного изменения. Для точного поведения сначала сохраните старое значение, затем увеличьте счётчик, затем сложите выбранные значения.

<?php
$nextNumber = 20;
$firstLabel = $nextNumber;
$nextNumber++;
$secondLabel = $nextNumber;
$nextNumber++;
echo 'Первая этикетка: ', $firstLabel, "\n";
echo 'Вторая этикетка: ', $secondLabel, "\n";
echo 'Следующий свободный номер: ', $nextNumber, "\n";

Первая этикетка: 20
Вторая этикетка: 21
Следующий свободный номер: 22

Сначала сохраняем 20 в firstLabel, потом увеличиваем nextNumber до 21. Затем сохраняем 21 во secondLabel и увеличиваем счётчик до 22. Каждая строка завершается до следующей, поэтому чтение номера не смешано с его изменением внутри одного арифметического выражения. Нумерация действует в одном процессе; параллельные запросы требуют общего хранилища и отдельной гарантии уникальности.

<?php
$available = true;
var_dump(!$available = false);
var_dump($available);

$available = false;
var_dump(!$available);

bool(true)
bool(false)
bool(true)

Первая запись разбирается как !($available = false): слева от присваивания нужна переменная, а не результат !$available. Такой код трудно читать. Последние две строки показывают прозрачную форму с отдельным присваиванием; в прикладном коде используйте её.

<?php
var_dump(+'14');
var_dump(-'2.5');
var_dump(14 / 2);
var_dump(15 / 2);
var_dump(14.0 / 2);
var_dump('14' / '2');

int(14)
float(-2.5)
int(7)
float(7.5)
float(7)
int(7)

Деление двух int (включая преобразованные целочисленные числовые строки) возвращает int, если делится нацело. В остальных случаях / возвращает float. Поэтому '/' не означает «всегда дробный тип».

<?php
try {
    $average = 120 / 0;
} catch (DivisionByZeroError $error) {
    echo "Нет элементов для среднего\n";
}
try {
    $sum = 'нет цены' + 20;
} catch (TypeError $error) {
    echo "Цена не является числом\n";
}
try {
    intdiv(PHP_INT_MIN, -1);
} catch (ArithmeticError $error) {
    echo "Частное не помещается в int\n";
}

Нет элементов для среднего
Цена не является числом
Частное не помещается в int

try/catch здесь делает крайние случаи видимыми. Обычно отсутствие элементов проверяют до деления и явно выбирают «нет среднего» вместо искусственного нуля. PHP_INT_MIN — минимальный int текущей платформы.

<?php
$slides = ['Чай', 'Кофе', 'Какао', 'Вода'];
$slideCount = count($slides);
$currentIndex = 0;
$previousIndex = ($currentIndex - 1) % $slideCount;
if ($previousIndex < 0) {
    $previousIndex += $slideCount;
}
echo 'Текущая карточка: ', $slides[$currentIndex], "\n";
echo 'Предыдущая карточка: ', $slides[$previousIndex], "\n";
echo 'Её индекс: ', $previousIndex, "\n";
echo 'Знаки остатка: ', 11 % 4, ', ', 11 % -4, ', ', -11 % 4, ', ', -11 % -4, "\n";
echo 'Остаток длины 7.5 м по 2 м: ', fmod(7.5, 2.0), ' м', "\n";

Текущая карточка: Чай
Предыдущая карточка: Вода
Её индекс: 3
Знаки остатка: 3, 3, -3, -3
Остаток длины 7.5 м по 2 м: 1.5 м

Count возвращает число карточек 4. Позиция перед нулём даёт -1; PHP сохраняет знак делимого в остатке, поэтому добавляем длину 4 и получаем индекс 3. Он действительно используется для чтения «Вода». Пустое кольцо недопустимо: делитель обязан быть положительным. Fmod принимает два float и возвращает дробный остаток; это не целочисленный %.

<?php
function splitKopecks(int $kopecks, int $parts): array
{
    if ($kopecks < 0 || $parts < 1 || $parts > 1000) {
        throw new InvalidArgumentException('Неверные границы');
    }
    $base = intdiv($kopecks, $parts);
    $remainder = $kopecks % $parts;
    $shares = array_fill(0, $parts, $base);
    for ($index = 0; $index < $remainder; $index++) {
        $shares[$index] += 1;
    }
    return $shares;
}
$shares = splitKopecks(101, 3);
echo implode(', ', $shares), "\n";
echo array_sum($shares), "\n";

34, 34, 33
101

Сумма частей сохранена. Порядок получателей определяет, кому достанутся дополнительные копейки; это должно быть частью бизнес-правила. Лимит 1000 ограничивает память примера, а не выражает общее правило PHP. Типы в сигнатуре описаны в главе функций.

<?php
var_dump(3 ** 0);
var_dump(3 ** 3);
var_dump(2 ** -3);

$attempt = 4;
$baseSeconds = 2;
$delay = min(30, $baseSeconds * (2 ** ($attempt - 1)));
echo 'Пауза: ', $delay, "\n";

int(1)
int(27)
float(0.125)
Пауза: 16

Здесь только вычисляется пауза, sleep не вызывается. В реальном retry ограничивают число попыток и общее время, учитывают Retry-After и при необходимости jitter. Само min после вычисления не защищает от чрезмерной исходной степени: сначала ограничьте attempt.

<?php
$side = 1.0e200;
$area = $side ** 2;
if (!is_finite($area)) {
    echo "Площадь не рассчитана: результат вне конечного диапазона\n";
}
$root = (-4.0) ** 0.5;
if (is_nan($root)) {
    echo "Корень не рассчитан: нет действительного результата\n";
}

Площадь не рассчитана: результат вне конечного диапазона
Корень не рассчитан: нет действительного результата

Степень side ** 2 переполнила диапазон float и дала INF. Is_finite возвращает false; отрицание ! выбирает сообщение о невозможном результате. Отрицательное основание в степени 0.5 даёт NAN: PHP не создаёт здесь комплексное число. Прикладной код решает, вернуть ошибку или запросить другой вход, прежде чем использовать результат в тарифе или отчёте.

<?php
$attempt = 1;
$shown = $attempt++;
echo 'Показали ', $shown, ', следующее ', $attempt, "\n";
$shown = ++$attempt;
echo 'Показали ', $shown, ', текущее ', $attempt, "\n";
$attempt--;
echo $attempt, "\n";

Показали 1, следующее 2
Показали 3, текущее 3
2

n++ возвращает прежнее значение выражения и увеличивает переменную; ++n возвращает уже увеличенное. В отдельной строке без использования результата они одинаково увеличивают счётчик. Аналогично работают --n и n--. Для понятного номера попытки зачастую лучше отдельное присваивание и отдельный ++.

<?php
$total = 0;
$label = 'Позиции: ';
foreach (['чай' => 150, 'кофе' => 200] as $name => $price) {
    $total += $price;
    $label .= $name . '; ';
}
echo $label, "\n", $total, "\n";

Позиции: чай; кофе; 
350

+= — прибавить и сохранить, .= — дописать строку. Есть -=, *=, /=, %=, **= и операции над битами. Для длинного списка подписей часто проще накопить массив и вызвать implode; большая выгрузка требует последовательной записи, чтобы не держать весь результат в памяти.

<?php
$lastCode = '009';
$number = $lastCode;
$number++;
$printed = str_pad((string) $number, 3, '0', STR_PAD_LEFT);
echo 'Исходная строка: ', $lastCode, "\n";
echo 'Следующее значение: ', $number, ' (', get_debug_type($number), ')', "\n";
echo 'Этикетка: Заказ №', $printed, "\n";

Исходная строка: 009
Следующее значение: 10 (int)
Этикетка: Заказ №010

Копия строки 009 при ++ стала int 10; исходная lastCode осталась строкой 009. Приведение (string) готовит "10" для форматирования; str_pad добавляет один ноль слева и возвращает 010 в printed. Это только оформление номера в одном процессе, уникальности между параллельными запросами здесь нет. В новом счётчике обычно сразу храните int, а строку формируйте при показе.

<?php
$remaining = 3;
$afterFirst = --$remaining;
echo 'После первого снятия: ', $afterFirst, ' шт.', "\n";
$beforeSecond = $remaining--;
echo 'Перед вторым снятием было: ', $beforeSecond, ' шт.', "\n";
echo 'Теперь осталось: ', $remaining, ' шт.', "\n";

После первого снятия: 2 шт.
Перед вторым снятием было: 2 шт.
Теперь осталось: 1 шт.

Префиксное -- сначала сохраняет 2 в remaining, а значение выражения 2 попадает в afterFirst. Постфиксное -- отдаёт прежнее 2 в beforeSecond и уменьшает remaining до 1. Это два последовательных снятия из известного запаса 3; в реальном резервировании отдельно запрещают отрицательный остаток и согласуют параллельные изменения.

<?php
// Только PHP 8.3+.
$code = 'R9';
$nextCode = str_increment($code);
echo $code, ' -> ', $nextCode, "\n";
echo str_increment('4e0'), "\n";

R9 -> S0
4e1

str_increment(string): string обрабатывает буквенно-цифровой ASCII-текст; пустая строка и другие символы дают ValueError. Строка 4e0 не становится float, в отличие от ++ над числовой строкой. Это преобразование кода, не генератор безопасных токенов и не счётчик заказов в базе.

<?php
$initial = $available = 20;
$available -= 5;
echo 'Вместимость: ', $initial, ' мест', "\n";
echo 'Занято: ', $initial - $available, ' мест', "\n";
echo 'Свободно: ', $available, ' мест', "\n";
echo 'После уточнения свободно: ', ($available = 7), ' мест', "\n";

Вместимость: 20 мест
Занято: 5 мест
Свободно: 15 мест
После уточнения свободно: 7 мест

В available сначала записано 20; значение этого присваивания 20 поступает в initial. -=5 меняет только available, разница равна 5. Последнее присваивание внутри скобок сохраняет 7 и отдаёт это же 7 в echo; это не сравнение. В обычной прикладной записи чаще яснее сначала отдельно обновить available, затем вывести его. Левая сторона = должна допускать запись; литералу вроде 20 присвоить значение нельзя.

<?php
$stock = 10;
$snapshot = $stock;
$alias =& $stock;
$alias -= 2;
echo 'Склад после резерва: ', $stock, ' шт.', "\n";
echo 'Снимок до резерва: ', $snapshot, ' шт.', "\n";
unset($alias);
$stock = 3;
echo 'Склад после сверки: ', $stock, ' шт.', "\n";
echo 'Старый снимок: ', $snapshot, ' шт.', "\n";

Склад после резерва: 8 шт.
Снимок до резерва: 10 шт.
Склад после сверки: 3 шт.
Старый снимок: 10 шт.

Snapshot получает независимое целое 10. =& делает alias вторым именем значения stock; вычитание через alias меняет stock на 8, что видно в отчёте. Unset убирает только имя alias, stock остаётся доступен. Последующая сверка ставит stock=3, старый snapshot всё ещё 10. Амперсанд здесь создаёт связь переменных и не является побитовым И. Обычное присваивание объектного значения имеет другой договор, описанный ниже.

<?php
$label = 'Заказ';
$full = $label . ' №' . 41;
echo $full, "\n";
echo $label, "\n";
$label .= ' принят';
echo $label, "\n";

Заказ №41
Заказ
Заказ принят

Обычная точка не изменила label. .= изменила. Число 41 преобразовано для текстового представления; массив так собирать не следует, а bool false/null могут незаметно превратиться в пустую строку.

<?php
function hasStock(array $item): bool {
    echo 'Проверяем остаток: ', $item['title'], "\n";
    return $item['stock'] > 0;
}
$item = null;
if ($item !== null && hasStock($item)) {
    echo "Первый поиск: товар доступен\n";
} else {
    echo "Первый поиск: доступного товара нет\n";
}
$item = ['title' => 'Чай', 'stock' => 3];
if ($item !== null && hasStock($item)) {
    echo 'Можно заказать: ', $item['title'], ', остаток ', $item['stock'], ' шт.', "\n";
}

Первый поиск: доступного товара нет
Проверяем остаток: Чай
Можно заказать: Чай, остаток 3 шт.

При null левое сравнение ложно, hasStock не вызвана: нет её сообщения и нет передачи null в параметр array. При найденной записи слева true; функция получает массив в местный item, показывает название и возвращает true из сравнения 3>0. Этот return становится правым операндом &&, итог true выбирает сообщение о доступности. У || достаточно true слева, чтобы не вызывать правую часть; ! меняет логический результат на противоположный.

<?php
$accountActive = true;
$paid = false;
$ready = $accountActive && $paid;
$wrong = $accountActive and $paid;
$explicit = ($accountActive and $paid);
echo 'Через &&: ', $ready ? 'можно выдать' : 'ожидаем оплату', "\n";
echo 'Через and без скобок: ', $wrong ? 'ошибочно разрешили выдачу' : 'ожидаем оплату', "\n";
echo 'Через and со скобками: ', $explicit ? 'можно выдать' : 'ожидаем оплату', "\n";

Через &&: ожидаем оплату
Через and без скобок: ошибочно разрешили выдачу
Через and со скобками: ожидаем оплату

&& связывается сильнее =: ready получает результат true&&false, то есть false. And связывается слабее =: в wrong сначала записывается accountActive=true; дальнейшее and false уже не меняет wrong. Скобки в третьем варианте включают обе проверки в присваиваемое выражение, поэтому explicit=false. Код показывает три учебных решения, реальной выдачи товара нет. Xor означает ровно одно истинное условие и тоже имеет низкий приоритет; используйте явные скобки.

<?php
$pickup = true;
$courier = false;
$exactlyOne = ($pickup xor $courier);
if ($exactlyOne) {
    echo "Выбор принят: самовывоз\n";
}
$courier = true;
$exactlyOne = ($pickup xor $courier);
if (!$exactlyOne) {
    echo "Исправьте выбор: одновременно отмечены два способа\n";
}
$label = 'самовывоз' || 'курьер';
echo 'Тип результата строк под ||: ', get_debug_type($label), "\n";

Выбор принят: самовывоз
Исправьте выбор: одновременно отмечены два способа
Тип результата строк под ||: bool

Первый xor получает true и false и отдаёт true в exactlyOne. Во второй ситуации оба флага true: возвращается false, поэтому !exactlyOne выбирает сообщение. Если оба false, xor также false — тогда сообщение должно просить выбрать способ. Последнее || вычисляет истинность строк и отдаёт bool, а не выбирает одну из подписей. Скобки вокруг xor важны из-за его приоритета ниже присваивания.

<?php
function courierAvailable(): bool
{
    echo "Проверяем курьерскую доставку\n";
    return false;
}
$pickup = true;
$anyMethod = $pickup || courierAvailable();
if ($anyMethod) {
    echo "Есть хотя бы один способ: заказ можно продолжить\n";
}
$exactlyOne = ($pickup xor courierAvailable());
if ($exactlyOne) {
    echo "Доступен ровно один способ: самовывоз\n";
}

Есть хотя бы один способ: заказ можно продолжить
Проверяем курьерскую доставку
Доступен ровно один способ: самовывоз

У || левое true уже определяет ответ: вызов справа пропущен, сообщения о проверке нет. Для xor нужны оба значения: функция печатает сообщение и возвращает false в правый операнд; true xor false даёт true. Имя courierAvailable здесь задаёт локальное учебное правило, не выполняет сетевой запрос. Проверку нельзя использовать для обязательного побочного действия: короткое замыкание может его пропустить.

<?php
$stock = 0;
$wrongStock = $stock ?: 10;
$shownStock = $stock ?? 10;
echo 'Ошибочная подстановка через ?: ', $wrongStock, ' шт.', "\n";
echo 'Известный остаток через ??: ', $shownStock, ' шт.', "\n";
echo $shownStock > 0 ? 'Можно заказать' : 'Товар закончился', "\n";

Ошибочная подстановка через ?: 10 шт.
Известный остаток через ??: 0 шт.
Товар закончился

Короткий ?: проверяет истинность: 0 ложно и выбирается 10. Оператор ?? подставляет запасное только для null или отсутствия; известное 0 сохраняется. Последнее полное условное выражение сравнивает число с нулём и возвращает строку «Товар закончился» в echo. Подмена через ?: дала бы ложное представление о наличии.

<?php
$settings = ['timeout' => null, 'retries' => 0];
$settings['timeout'] ??= 5;
$settings['retries'] ??= 3;
$settings['pause'] ??= 1;
echo 'Ожидание: ', $settings['timeout'], ' с', "\n";
echo 'Повторных попыток: ', $settings['retries'], "\n";
echo 'Пауза между попытками: ', $settings['pause'], ' с', "\n";

Ожидание: 5 с
Повторных попыток: 0
Пауза между попытками: 1 с

??= не только выбирает, но и записывает: null в timeout заменён на 5, отсутствующий pause создан со значением 1, заданный retries=0 сохранён. Пример готовит конфигурацию; он не спит, не повторяет запросы и не устанавливает таймаут PHP автоматически. Вложенные полные ?: в PHP 8 требуют явных скобок; для нескольких действий выбирайте if или match.

<?php
function backupLabel()
{
    echo "Вычисляем запасную подпись\n";
    return 'Гость';
}
$name = 'Анна';
echo $name ?? backupLabel(), "\n";
$name = null;
echo $name ?? backupLabel(), "\n";
$custom = '';
$account = 'Покупатель';
echo $custom ?: $account ?: 'Гость', "\n";

Анна
Вычисляем запасную подпись
Гость
Покупатель

?? не исполняет правую сторону без необходимости. ?: с пустым custom берёт account. Если отсутствующая подпись должна стать ошибкой, запасной текст лишь замаскирует проблему — решение зависит от задачи.

<?php
$count = 0;
echo $count ?? 5 . ' товаров', "\n";
echo ($count ?? 5) . ' товаров', "\n";
$input = [];
echo 'Имя: ' . ($input['name'] ?? 'не задано'), "\n";

0
0 товаров
Имя: не задано

В первой строке точка связывает только резервное значение 5 с припиской; поскольку count уже 0, ветка с припиской не нужна. Последняя запись безопасно читает отсутствующий ключ, но не доказывает, что input содержит все обязательные поля.

<?php
const READ_ACCESS = 1;
const WRITE_ACCESS = 2;
const DELETE_ACCESS = 4;
function actionLabels(int $flags): array {
    $labels = [];
    foreach ([READ_ACCESS => 'читать', WRITE_ACCESS => 'записывать', DELETE_ACCESS => 'удалять'] as $mask => $label) {
        if (($flags & $mask) === $mask) { $labels[] = $label; }
    }
    return $labels;
}
$flags = READ_ACCESS | WRITE_ACCESS;
echo 'Начало: ', implode(', ', actionLabels($flags)), "\n";
$flags &= ~WRITE_ACCESS;
echo 'После снятия записи: ', implode(', ', actionLabels($flags)), "\n";
$flags ^= READ_ACCESS;
$text = implode(', ', actionLabels($flags));
echo 'После переключения чтения: ', $text === '' ? 'действий нет' : $text, "\n";

Начало: читать, записывать
После снятия записи: читать
После переключения чтения: действий нет

OR объединяет 1 и 2 в 3. Первый вызов actionLabels получает местный flags=3: & с масками 1/2/4 даёт 1/2/0; первые две проверки истинны, return возвращает [читать,записывать] в implode. Implode соединяет их для echo. &=~2 убирает бит записи и оставляет 1; следующий вызов возвращает только чтение. ^=1 переключает оставшийся бит, получается 0 и пустой список. XOR при повторении отменит первое переключение, поэтому для безусловного снятия используйте &=~MASK. Скобки вокруг & нужны из-за приоритета сравнения.

<?php
for ($position = 0; $position < 4; $position++) {
    echo 'Позиция ', $position, ': ', 1 << $position, "\n";
}
echo 8 >> 1, "\n";

Позиция 0: 1
Позиция 1: 2
Позиция 2: 4
Позиция 3: 8
4

Сдвиг перемещает биты внутри целого ограниченной разрядности. Переполнение, отрицательные числа и знак делают его плохой заменой обычному умножению. У строк &|^ работают побайтово, когда оба операнда строки; не путайте строковые "1" и "2" с числовой маской.

<?php
echo bin2hex('A' & 'a'), "\n";
echo bin2hex('A' | 'a'), "\n";
echo bin2hex('A' ^ 'a'), "\n";
echo bin2hex(~'A'), "\n";
var_dump('12' & '10');
var_dump(12 & 10);
var_dump('12' << '1');

41
61
20
be
string(2) "10"
int(8)
int(24)

bin2hex показывает байты шестнадцатерично, включая непечатные. Это не операция над Unicode-буквами; инверсия байтов UTF-8 обычно разрушит текст. Последняя строка остаётся числовым сдвигом, хотя оба исходных значения — строки.

<?php
$frame = "\x12\x34";
$eventBytes = $frame & "\x00\xff";
$eventCode = ord($eventBytes[1]);
$eventNames = [52 => 'Открыта дверь'];
echo 'Байты после маски: ', bin2hex($eventBytes), "\n";
echo 'Код события: ', $eventCode, "\n";
echo 'Событие: ', $eventNames[$eventCode], "\n";

Байты после маски: 0034
Код события: 52
Событие: Открыта дверь

Оба операнда & — строки, поэтому результат тоже строка из двух байтов 00/34. Индекс [1] читает второй байт, ord превращает hex34 в десятичное 52. Это число становится ключом eventNames и выбирает настоящую подпись. Формат сообщения здесь учебный и длина заранее равна двум байтам. Для внешнего потока отдельно проверьте длину, разрешённые флаги, код и правила протокола. Побайтовая операция не является преобразованием Unicode-текста.

<?php
echo -7 >> 1, "\n";
echo intdiv(-7, 2), "\n";
$bits = PHP_INT_SIZE * 8;
echo 1 << $bits, "\n";
echo -1 >> $bits, "\n";
echo ~0, "\n";
try {
    $invalid = 1 << -1;
} catch (ArithmeticError $error) {
    echo "Отрицательный сдвиг запрещён\n";
}

-4
-3
0
-1
-1
Отрицательный сдвиг запрещён

Отрицательный сдвиг не означает сдвиг в другую сторону. Биты, вытолкнутые за границу int, не возвращаются. Если протокол использует большие беззнаковые значения, проверьте разрядность и выберите подходящее представление или GMP.

<?php
$code = 0x1234;
$deviceType = ($code >> 8) & 0xff;
$command = $code & 0xff;
echo 'Тип устройства: ', $deviceType, "\n";
echo 'Команда: ', $command, "\n";
$restored = ($deviceType << 8) | $command;
echo 'Восстановленный числовой код: ', $restored, "\n";
if ($restored === $code) {
    echo "Оба поля восстановлены без потери\n";
}

Тип устройства: 18
Команда: 52
Восстановленный числовой код: 4660
Оба поля восстановлены без потери

В условном 16-битном формате старшие восемь бит — тип, младшие — команда. Сдвиг >> 8 переносит старшее поле вниз, & 0xff оставляет восемь младших битов. При сборке << 8 возвращает тип на место, | объединяет непересекающиеся биты. 0x1234 — шестнадцатеричный литерал числа 4660. Это разбор числа; отправка байтов в сеть и порядок байтов требуют отдельного договора протокола.

<?php
$custom = ['delivery' => 0, 'method' => 'Самовывоз'];
$defaults = ['delivery' => 150, 'packaging' => 20];
$options = $custom + $defaults;
$goods = 300;
$total = $goods + $options['delivery'] + $options['packaging'];
echo 'Получение: ', $options['method'], "\n";
echo 'Доставка: ', $options['delivery'], ' руб.', "\n";
echo 'Упаковка: ', $options['packaging'], ' руб.', "\n";
echo 'К оплате: ', $total, ' руб.', "\n";

Получение: Самовывоз
Доставка: 0 руб.
Упаковка: 20 руб.
К оплате: 320 руб.

Delivery уже есть слева и остаётся 0; method тоже берётся из custom. Ключ packaging отсутствовал, поэтому справа добавляется 20. Итог использует реальные полученные настройки: 300+0+20=320. Это объединение только верхнего уровня. Для вложенных правил нужна отдельная политика; пример ниже объясняет её границы.

<?php
$morning = ['Чай', 'Кофе'];
$afternoon = ['Чашки', 'Тарелки'];
$union = $morning + $afternoon;
$merged = array_merge($morning, $afternoon);
echo "Результат +:\n";
foreach ($union as $index => $title) { echo $index, ': ', $title, "\n"; }
echo "Результат array_merge:\n";
foreach ($merged as $index => $title) { echo $index, ': ', $title, "\n"; }

Результат +:
0: Чай
1: Кофе
Результат array_merge:
0: Чай
1: Кофе
2: Чашки
3: Тарелки

Оба списка имеют ключи 0/1. При + правые записи с этими ключами не добавились: остались только Чай/Кофе. Array_merge добавляет элементы с числовыми ключами и нумерует результат заново, поэтому видны все четыре названия. При совпадении строковых ключей у array_merge побеждает правая запись. Ни один из этих способов не является универсальным глубоким объединением конфигурации.

<?php
$saved = ['sku' => 'TEA', 'stock' => 2];
$incoming = ['stock' => 2, 'sku' => 'TEA'];
if ($saved == $incoming) { echo "Значения полей не изменились\n"; }
if ($saved !== $incoming) { echo "Строгий снимок отличается порядком полей\n"; }
$sameOrder = ['sku' => $incoming['sku'], 'stock' => $incoming['stock']];
if ($saved === $sameOrder) { echo "После явного порядка ключей снимки совпали\n"; }
$incoming['stock'] = '2';
if ($saved == $incoming) { echo "Нестрогое сравнение также приняло строку 2\n"; }
if (!is_int($incoming['stock'])) { echo "Вход отклонён: stock должен быть int\n"; }

Значения полей не изменились
Строгий снимок отличается порядком полей
После явного порядка ключей снимки совпали
Нестрогое сравнение также приняло строку 2
Вход отклонён: stock должен быть int

При первых входах == находит одинаковые пары независимо от порядка. === дополнительно требует одинаковые порядок и типы, поэтому первоначально снимки различаются. Явное построение sameOrder сохраняет значения и делает порядок одинаковым. После подмены int 2 строкой "2" нестрогое равенство всё ещё истинно, но отдельная проверка схемы отклоняет вход. Ни ==, ни === не заменяет проверку обязательных ключей, типов и диапазонов внешней записи; здесь все ключи заранее заданы.

<?php
$options = ['http' => ['retries' => 0], 'label' => null];
$defaults = ['http' => ['timeout' => 5], 'label' => 'API', 'debug' => false];
$options += $defaults;
echo 'Повторов: ', $options['http']['retries'], "\n";
if (!array_key_exists('timeout', $options['http'])) {
    echo "Timeout отсутствует: вложенный словарь не дополнен\n";
}
if ($options['label'] === null) {
    echo "Подпись намеренно отсутствует\n";
}
echo 'Отладка: ', $options['debug'] ? 'включена' : 'выключена', "\n";
$options['http'] += $defaults['http'];
echo 'После отдельного дополнения HTTP: ', $options['http']['timeout'], ' с', "\n";

Повторов: 0
Timeout отсутствует: вложенный словарь не дополнен
Подпись намеренно отсутствует
Отладка: выключена
После отдельного дополнения HTTP: 5 с

Первый += сравнил только http, label, debug верхнего уровня. Http и label уже существуют слева, поэтому их целые значения сохранены, включая null; debug добавлен. Array_key_exists проверяет ключ независимо от null. Последний += применён явно к вложенному HTTP-массиву и добавил timeout = 5. Для неизвестной схемы такой отдельной строки недостаточно: нужен заранее согласованный алгоритм слияния.

<?php
var_dump(null == '');
var_dump(null == '0');
var_dump(null == 0);
var_dump(false == '0');
var_dump(0 == 'нет');
var_dump('020' == '20');
var_dump('020' === '20');
var_dump('0e12' == '0e34');
var_dump(20 === 20.0);
var_dump('A' == 'a');
var_dump(4 <> 5);

bool(true)
bool(false)
bool(true)
bool(true)
bool(false)
bool(true)
bool(false)
bool(true)
bool(false)
bool(false)
bool(true)

0e12 и 0e34 — разные тексты, но оба представляют числовой ноль. Для артикула с ведущими нулями нужен строковый договор. Проверку сохранённых паролей выполняют password_verify, сравнение секретных MAC — hash_equals при корректном договоре входа, а не подбором ==/===.

<?php
echo 120 <=> 200, "\n";
echo 200 <=> 200, "\n";
echo 300 <=> 200, "\n";

-1
0
1

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

<?php
$orders = [
    ['id' => 7, 'price' => 500],
    ['id' => 2, 'price' => 300],
    ['id' => 3, 'price' => 500],
];
usort($orders, function ($left, $right) {
    $byPrice = $left['price'] <=> $right['price'];
    if ($byPrice !== 0) {
        return $byPrice;
    }
    return $left['id'] <=> $right['id'];
});
foreach ($orders as $order) {
    echo $order['id'], ':', $order['price'], "\n";
}

2:300
3:500
7:500

Ответ API не сортируется автоматически по нужному бизнес-полю. Компаратор должен быть согласованным; произвольное сравнение двух массивов разного состава такого договора не даёт. usort меняет исходный массив и перенумеровывает числовые ключи.

<?php
$average = NAN;
if ($average < 0) {
    echo "Отрицательное среднее\n";
}
if (!is_finite($average)) {
    echo "Среднее не готово: нужен конечный результат\n";
} elseif ($average >= 0) {
    echo 'Среднее: ', $average, "\n";
}

Среднее не готово: нужен конечный результат

NAN не меньше нуля, но из этого не следует, что число допустимо или >= 0. Сравнения NAN с обычным числом и собой ==/===//<=/>= дают false, !=/!== дают true. Проверка конечности останавливает ошибочный маршрут прежде, чем число попадёт в отчёт. Для точного распознавания NAN используют is_nan.

<?php
$measuredMeters = 0.1 + 0.2;
$targetMeters = 0.3;
$toleranceMeters = 0.000001;
$difference = abs($measuredMeters - $targetMeters);
if (is_finite($measuredMeters) && $difference <= $toleranceMeters) {
    echo "Деталь принята: отклонение не больше 0.000001 м\n";
} else {
    echo "Деталь требует проверки\n";
}
echo 'Размер для подписи: ', $measuredMeters, ' м', "\n";

Деталь принята: отклонение не больше 0.000001 м
Размер для подписи: 0.3 м

Abs принимает разность и возвращает её величину без знака. Сначала проверяется конечность, затем величина отклонения. Арифметика float не обязана дать строго то же двоичное значение, что литерал 0.3; визуальная подпись 0.3 не доказывает точное равенство. Абсолютный допуск здесь выбран в метрах для этой задачи. Для других масштабов нужен согласованный относительный допуск; для денег этот приём не заменяет правила округления.

<?php
// Требуется PHP 8.5 или новее.
$raw = '  sku-17  ';
$trimmed = trim($raw);
$normal = strtoupper($trimmed);
echo $normal, "\n";
echo strtoupper(trim($raw)), "\n";
echo ($raw |> trim(...) |> strtoupper(...)), "\n";

SKU-17
SKU-17
SKU-17

trim(...) здесь создаёт вызываемое значение через first-class callable, а не вызывает trim без аргументов. Первый вариант подходит для поэтапной отладки; конвейер удобен, когда шаги короткие и понятные. На PHP 8.2–8.4 используйте первые два варианта.

<?php
// Требуется PHP 8.5 или новее.
$prefix = 'ORDER-';
$result = '  17  '
    |> trim(...)
    |> (fn(string $number): string => $prefix . $number);
echo $result, "\n";

ORDER-17

Стрелочная функция принимает промежуточное значение и использует prefix из внешней области. Каждая ступень обязана принимать результат предыдущей. Исключение остановит конвейер; |> сам не перехватывает ошибки и не делает синхронный HTTP-запрос неблокирующим.

<?php
// Только PHP 8.5+.
class PrefixOrder {
    public function __invoke($number) {
        return 'ORDER-' . $number;
    }
}
$prefix = new PrefixOrder();
$result = '  41  ' |> trim(...) |> $prefix;
echo $result, "\n";

ORDER-41

__invoke позволяет вызвать объект как функцию. Конвейер сначала передал строку trim, затем его результат 41 — объекту prefix. То же можно написать промежуточными переменными на PHP 8.2–8.4.

<?php
// Только PHP 8.5+.
function joinCode($prefix, $number) {
    return $prefix . $number;
}
try {
    $result = 41 |> joinCode(...);
} catch (ArgumentCountError $error) {
    echo "Не хватает второго аргумента\n";
}
try {
    $result = 41 |> 123;
} catch (Error $error) {
    echo "Правая часть не callable\n";
}
$result = 41 |> (fn($number) => joinCode('ORDER-', $number));
echo $result, "\n";

Не хватает второго аргумента
Правая часть не callable
ORDER-41

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

<?php
// Только PHP 8.5+.
$values = [7, 3];
try {
    $result = $values |> sort(...);
} catch (Error $error) {
    echo "Прямая передача по ссылке не поддерживается\n";
}
$sorted = $values |> (function ($items) {
    sort($items);
    return $items;
});
echo implode(', ', $values), "\n";
echo implode(', ', $sorted), "\n";

Прямая передача по ссылке не поддерживается
7, 3
3, 7

sort изменяет свой аргумент по ссылке и возвращает bool, а не отсортированный массив. Явный шаг получает локальную копию массива, сортирует её и возвращает массив следующему коду. Исходные values остались прежними. Такая обёртка задаёт смысл преобразования, а не просто устраняет сообщение об ошибке.

<?php
declare(strict_types=1);

$path = __DIR__ . '/missing-catalog.txt';
if (!is_file($path)) {
    echo "Каталог ещё не получен\n";
} else {
    $text = file_get_contents($path);
    if ($text === false) {
        throw new RuntimeException('Не удалось прочитать каталог');
    }
    echo $text;
}

Каталог ещё не получен

Для учебного отсутствующего файла мы отличили нормальное состояние «ещё не пришёл» от результата чтения. Проверка is_file не устраняет гонку: файл может исчезнуть после неё. В настоящем обработчике нужна согласованная политика предупреждений/исключений и проверка самого чтения. Приём с @ не заменяет эту политику.

<?php
error_clear_last();
$text = @file_get_contents(__DIR__ . '/absent.txt');
$lastError = error_get_last();
if ($text === false) {
    $text = 'Выдача заказов с 10 до 18';
    echo "Использована памятка по умолчанию\n";
}
if ($lastError !== null && $lastError['type'] === E_WARNING) {
    echo "Зафиксировано предупреждение чтения\n";
}
echo 'Памятка: ', $text, "\n";

Использована памятка по умолчанию
Зафиксировано предупреждение чтения
Памятка: Выдача заказов с 10 до 18

Файл намеренно отсутствует. @ скрывает обычный вывод предупреждения, но file_get_contents возвращает false: это проверяется до использования text. Затем выбирается конкретная заранее допустимая памятка и выводится её текст. Error_get_last прочитан сразу после отказа: массив содержит type/message/file/line; следующая ошибка могла бы заменить запись. Внешнему читателю здесь показывается безопасная подпись, внутренний путь не выводится. Этот пример объясняет механизм @, а не правило скрывать любые ошибки.

<?php
set_error_handler(function ($severity, $message) {
    echo (error_reporting() & $severity) === 0
        ? "Обработчик вызван для подавленного уровня\n"
        : "Обработчик вызван для включённого уровня\n";
    return true;
});
try {
    $text = @file_get_contents(__DIR__ . '/absent.txt');
    if ($text === false) { echo "Файл не прочитан, содержимое не используется\n"; }
} finally {
    restore_error_handler();
}
try {
    $result = @(1 / 0);
} catch (DivisionByZeroError) {
    echo "Деление не выполнено: делитель равен нулю\n";
}

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

PHP всё равно вызывает наш обработчик с severity/message. Проверка пересечения битов обнаруживает, что этот уровень подавлен. Return true относится к обработке предупреждения, а не к результату чтения: text остаётся false и следующая ветка отказывается от содержимого. Finally восстанавливает обработчик. Во втором опыте @ не убирает DivisionByZeroError: вместо значения в result управление переходит к catch. В PHP 8 под @ остаются критические уровни, поэтому проверять error_reporting()===0 неправильно.

<?php
$output = `echo READY`;
// Исторический shell-синтаксис; не образец для нового кода.

Контекстный исторический фрагмент, команда здесь не запускалась. Вывод команды попал бы в $output, а не автоматически в HTTP-ответ. СPHP8.5 оператор обратных кавычек deprecated. Синтаксис зависит от оболочки; не подставляйте пользовательский текст в команду.

<?php
class Receipt {
    public $number = 41;
}
$receipt = new Receipt();
$className = Receipt::class;
var_dump($receipt instanceof Receipt);
var_dump($className instanceof Receipt);
var_dump(null instanceof Receipt);
var_dump(!($receipt instanceof stdClass));

bool(true)
bool(false)
bool(false)
bool(true)

Receipt::class возвращает строку имени. Она сама не объект Receipt. ! меняет результат проверки; скобки делают это явно читаемым. Необъект слева даёт false; литералы допустимы с PHP7.3.

<?php
interface PrintableReceipt {
    public function text(): string;
}
class Receipt {}
class GiftReceipt extends Receipt implements PrintableReceipt {
    public function text(): string { return 'Подарочный чек №41'; }
}
$receipt = new GiftReceipt();
var_dump($receipt instanceof Receipt);
if ($receipt instanceof PrintableReceipt) {
    echo $receipt->text(), "\n";
}
$type = PrintableReceipt::class;
var_dump($receipt instanceof $type);
$another = new GiftReceipt();
var_dump($receipt instanceof $another);
var_dump($receipt === $another);
var_dump($receipt instanceof ('Printable' . 'Receipt'));

bool(true)
Подарочный чек №41
bool(true)
bool(true)
bool(false)
bool(true)

Строка или объект справа задают проверяемый класс/интерфейс, но не требуют идентичности экземпляра. Произвольное выражение справа поддерживается с PHP8.0, оборачивается в скобки и должно дать строку имени. Для строки имени применим is_a с явным allow_string, для существования определения — class_exists; это разные вопросы.

<?php
declare(strict_types=1);

$position = strpos('SKU-204 Cable', 'SKU-');
if ($position !== false) {
    echo "Найдено на позиции {$position}\n";
}
echo str_starts_with('SKU-204 Cable', 'SKU-') ? "Начинается сSKU\n" : "Нет\n";

Найдено на позиции 0
Начинается сSKU

if ($position) пропустит совпадение вначале: позиция 0 преобразуется в false. Когда позиция не нужна, str_contains или str_starts_with точнее выражают вопрос. Это повторяющаяся проблема из обсуждений разработчиков.

<?php
declare(strict_types=1);

$product = ['stock' => 0, 'subtitle' => null];
echo $product['stock'] ?? 99, "\n";
echo $product['stock'] ?: 99, "\n";
echo $product['subtitle'] ?? 'Без подзаголовка', "\n";

0
99
Без подзаголовка

?? выбирает запасное значение только для отсутствия/null. Сокращенный тернарный ?: проверяет истинность и заменит 0. Для склада это искажает данные. Nullsafe?-> останавливает цепочку при null-объекте, но не подавляет исключения методов и не валидирует JSON-массив.

<?php
declare(strict_types=1);

$input = ['quantity' => '4'];
$valid = isset($input['quantity'])
    && is_string($input['quantity'])
    && preg_match('/\A[1-9][0-9]?\z/', $input['quantity']) === 1;
echo $valid ? "Можно продолжить\n" : "Ошибка формы\n";

Можно продолжить

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