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

<?php
$stock = 12;
$available =& $stock;
$available = 10;
echo $stock;

10

available не хранит независимую копию числа: изменение видно через stock. Здесь мы изучаем механизм; для складской системы с одновременными заказами одних переменных в памяти процесса недостаточно.

<?php
$stock = 12;
$available = $stock;
$available = 10;
echo $stock;

12

Без & изменение второго числа не меняет первое. PHP может использовать внутренние оптимизации памяти, но они не отменяют это наблюдаемое различие. Не добавляйте & просто ради предположения об экономии памяти.

<?php
$firstStock = 12;
$secondStock = 20;
$current =& $firstStock;
$current =& $secondStock;
$current = 21;
echo $firstStock, '/', $secondStock;

12/21

current теперь связан со secondStock; firstStock остался 12. Символ / в выводе — обычный разделитель текста. Поэтому функция, перепривязавшая свой локальный параметр, не обязательно перепривяжет переменную вызывающего кода.

<?php
$count = 3;
$alias =& $count;
$snapshot = $alias;
$alias = 4;
echo $count, '/', $snapshot;

4/3

snapshot получил обычное число, а не ещё один ярлык. Чтобы присоединить третий ярлык, потребовалось бы $snapshot =& $alias. У массивов с внутренними ссылками и объектов есть дополнительные правила, которые ниже разобраны отдельно.

<?php
$count = 3;
$alias =& $count;
unset($alias);
$alias = 9;
echo $count, '/', $alias;

3/9

После unset новое присваивание создаёт отдельную переменную. Так разрывают временную связь после foreach по ссылке. Это не удаление товара из массива: для него нужно unset($items[$key]).

<?php
$count = 3;
$alias =& $count;
$alias = null;
var_dump($count);

NULL

var_dump показывает тип и значение. Оба имени всё ещё связаны; null видно через count. isset не отличает такую переменную от отсутствующей: он проверяет наличие ненулевого значения.

<?php
$order = [];
$comment =& $order['comment'];
if (array_key_exists('comment', $order)) {
    echo 'Поле уже существует: ', $order['comment'] ?? 'ещё не заполнено', "\n";
}
$comment = 'Позвонить заранее';
echo 'Памятка сборщику: ', $order['comment'], "\n";

Поле уже существует: ещё не заполнено
Памятка сборщику: Позвонить заранее

Связь с отсутствующим comment создала этот ключ со значением null. Array_key_exists возвращает true и разрешает первую подпись; ?? подставляет текст для null. Запись через comment затем меняет поле самого order, откуда берётся памятка. Обычное чтение order[comment] ?? null не создало бы ключ. Поэтому параметр по ссылке нельзя бездумно добавлять к функции, которая должна лишь проверить наличие данных.

<?php
declare(strict_types=1);

$stock = 12;
$available =& $stock;
$available -= 2;
echo 'Остаток: ', $stock, "\n";

unset($available);
$available = 99;
echo 'Старый остаток: ', $stock, "\n";
echo 'Новая переменная: ', $available, "\n";

Остаток: 10
Старый остаток: 10
Новая переменная: 99

=& связывает два имени с одним значением. Изменение через available поэтому видно через stock. unset убирает имя available из этой связи, а не обнуляет stock. Последующее присваивание создаёт отдельную переменную. Это демонстрация механики, не рекомендованная архитектура складского учёта.

<?php
function markSent(&$status)
{
    $status = 'sent';
}
$status = 'new';
markSent($status);
echo $status;

sent

Вызов не присваивал результат, но status изменился. Такое поведение должно быть очевидно из имени и документации функции. Другой вариант — переписать функцию на возврат нового значения через return и присвоить этот результат снаружи. Не присваивайте результат текущей markSent: она не возвращает значение и даст null.

<?php
function addOne(int &$count): void
{
    $count += 1;
}
try {
    addOne(3);
} catch (Error $error) {
    echo "Нужна переменная\n";
}

Нужна переменная

PHP не может связать параметр с литералом. Создайте $count = 3, затем вызовите addOne($count). Старый синтаксис вызова addOne(&$count) в современных версиях не применяется.

<?php
$weights = [300, 100, 200];
$status = sort($weights, SORT_NUMERIC);
if ($status) { echo "Массы упорядочены\n"; }
foreach ($weights as $position => $grams) {
    echo 'Образец ', $position + 1, ': ', $grams, ' г', "\n";
}

Массы упорядочены
Образец 1: 100 г
Образец 2: 200 г
Образец 3: 300 г

Sort изменяет сам weights через ссылочный первый параметр и возвращает true в status. Проверка статуса разрешает подпись; foreach читает готовые массы из weights. Прежние ключи заменены 0/1/2, поэтому здесь это номера образцов в новом порядке, не постоянные ID. Присваивание weights = sort(weights) подменило бы массив значением true.

<?php
declare(strict_types=1);

function reserveUnits(int &$available, int $quantity): void
{
    if ($quantity < 1 || $quantity > $available) {
        throw new InvalidArgumentException('Недостаточный остаток или неверное количество');
    }
    $available -= $quantity;
}

$stock = 5;
reserveUnits($stock, 2);
echo 'После резерва: ', $stock, "\n";
try {
    reserveUnits($stock, 20);
} catch (InvalidArgumentException) {
    echo "Резерв отклонён\n";
}
echo 'После отказа: ', $stock, "\n";

После резерва: 3
Резерв отклонён
После отказа: 3

Знак & стоит в объявлении параметра. Вызов reserveUnits($stock, 2) передаёт переменную без дополнительного &: функция получает право изменить именно её. Проверка выполнена до изменения, поэтому отказ оставляет 3. Это память одного процесса; параллельные заказы требуют отдельной транзакции/протокола резервирования в хранилище.

<?php
function chooseOther(&$current, &$other): void
{
    $current =& $other;
    $current = 9;
}
$first = 3;
$second = 7;
chooseOther($first, $second);
echo $first, '/', $second;

3/9

first осталось 3, second изменилось на 9. Если требуется заменить значение first значением second, внутри функции нужно обычное $current = $other, без перепривязки.

<?php
function forgetLocal(&$value): void
{
    unset($value);
    $value = 'local';
}
$status = 'new';
forgetLocal($status);
echo $status;

new

Удалено локальное имя value. Новое присваивание относится к новой локальной переменной. Для удаления поля передайте сам массив и нужный ключ, затем выполните unset($array[$key]) с понятным контрактом.

<?php
function &draftNote(): string
{
    static $note = 'new';
    return $note;
}
$editable =& draftNote();
$editable = 'review';
$copy = draftNote();
$copy = 'local';
echo draftNote(), '/', $copy;

review/local

static сохраняет note между вызовами в пределах одного выполнения PHP. Обычные HTTP-запросы FPM начинают это состояние заново, даже если процесс повторно используется. У длительного CLI-worker одно выполнение может обрабатывать много заданий. editable связан с note, copy получил обычную строку. Для независимых заказов используйте явное хранилище или объект; этот static не является сохранением заметки между HTTP-запросами.

<?php
function &cartRow(array &$rows, string $sku): array {
    if (!array_key_exists($sku, $rows)) {
        throw new OutOfBoundsException('Нет такого артикула');
    }
    return $rows[$sku];
}
$cart = ['tea' => ['quantity' => 1, 'price' => 150], 'cup' => ['quantity' => 2, 'price' => 200]];
$row =& cartRow($cart, 'tea');
$row['quantity'] = 3;
unset($row);
$total = 0;
foreach ($cart as $sku => $line) {
    $lineTotal = $line['quantity'] * $line['price'];
    $total += $lineTotal;
    echo $sku, ': ', $line['quantity'], ' × ', $line['price'], ' = ', $lineTotal, ' коп.', "\n";
}
echo 'К оплате: ', $total, ' коп.', "\n";

tea: 3 × 150 = 450 коп.
cup: 2 × 200 = 400 коп.
К оплате: 850 коп.

Первый & у параметра rows связывает его с исходной cart. Амперсанд перед именем функции обещает возврат ссылки на выбранную строку rows[tea]; =& у вызывающего сохраняет эту связь в row. Присваивание quantity=3 меняет строку cart, после чего unset снимает временное имя. Следующий foreach читает уже 3, считает 450+400=850 и показывает итог. Без =& получатель получил бы независимое значение массива. Форма/цены/количества заранее проверены; поиск по ссылке сам не делает валидацию или запись в базу.

<?php
function &attemptCounter(): int
{
    static $count = 0;
    return $count;
}
function recordAttempt(int &$count): void
{
    $count += 1;
}
recordAttempt(attemptCounter());
echo attemptCounter();

1

Здесь допустим результат вызова: attemptCounter явно возвращает по ссылке. Обычную функцию, возвращающую число по значению, подставлять вместо неё нельзя. В прикладном коде такой скрытый счётчик усложняет тесты; явная переменная или объект обычно понятнее.

<?php
declare(strict_types=1);

$broken = [2, 3, 4];
foreach ($broken as &$value) {
    $value *= 2;
}
// Ошибка: $value всё ещё связан с последним элементом.
foreach ($broken as $value) {
    // Даже пустое тело не отменяет присваивание в $value на каждой итерации.
}
echo 'Без unset: ', json_encode($broken, JSON_THROW_ON_ERROR), "\n";
unset($value);

$fixed = [2, 3, 4];
foreach ($fixed as &$value) {
    $value *= 2;
}
unset($value);
foreach ($fixed as $value) {
}
echo 'С unset: ', json_encode($fixed, JSON_THROW_ON_ERROR), "\n";

Без unset: [4,6,6]
С unset: [4,6,8]

В первом цикле изменили элементы на месте. После него $value сохранил связь с последним элементом. Второй цикл присваивал этому же имени прочитанные значения и незаметно менял последний элемент. В исправленном варианте связь снята сразу после первого цикла. Альтернатива без ссылок: foreach ($items as $key => $value) { $items[$key] = $value * 2; }.

<?php
$order = ['quantity' => 2, 'label' => 'first'];
$quantity =& $order['quantity'];
$snapshot = $order;
$snapshot['quantity'] = 5;
$snapshot['label'] = 'copy';
echo $order['quantity'], '/', $order['label'], "\n";
echo $snapshot['quantity'], '/', $snapshot['label'];

5/first
5/copy

quantity оказался общим, label остался независимым. Ошибка не случайна и не зависит от похожести имён. Нужно понимать, какие элементы уже были ссылками к моменту копирования.

<?php
$order = ['quantity' => 2];
$quantity =& $order['quantity'];
$quantity = 3;
unset($quantity);
$snapshot = $order;
$snapshot['quantity'] = 5;
echo $order['quantity'], '/', $snapshot['quantity'];

3/5

В этой структуре удалён единственный дополнительный alias до копирования. Это не универсальная функция разрыва всех вложенных связей: если другие ссылки остаются, контракт другой. Не используйте JSON-круговорот как универсальное клонирование: он меняет типы, теряет возможности объектов и не поддерживает циклы.

<?php
$mode = 'web';
function localMode(): void
{
    global $mode;
    $temporary = 'cli';
    $mode =& $temporary;
    $mode = 'worker';
}
localMode();
echo $mode;

web

Обычное $mode = 'worker' сразу после global изменило бы глобальное значение. Но здесь локальное имя сначала переведено к temporary. Это ещё одна причина избегать неочевидных перепривязок в конфигурации.

<?php
$handled = 0;
$onHandled = function () use (&$handled): void {
    $handled += 1;
};
$onHandled();
$onHandled();
echo $handled;

2

use перечисляет внешние переменные, & связывает handled с ними. Без & функция получила бы значение при создании замыкания и не меняла внешний handled. Здесь два последовательных локальных вызова; это не потокобезопасный счётчик общей очереди.

<?php
declare(strict_types=1);

class Address
{
    public function __construct(public string $city) {}
}

$first = new Address('Москва');
$second = $first;
$second->city = 'Казань';
echo 'Общий объект: ', $first->city, "\n";

$second = new Address('Тверь');
echo 'После нового объекта: ', $first->city, '/', $second->city, "\n";

$alias =& $first;
$alias = new Address('Омск');
echo 'После замены через ссылку: ', $first->city, "\n";
unset($alias);

Общий объект: Казань
После нового объекта: Казань/Тверь
После замены через ссылку: Омск

Обычное $second = $first копирует идентификатор того же объекта: оба имени позволяют изменить его city. Но переназначение second на новый Address не меняет first. С =& связь относится к самой переменной: переназначение alias меняет и то, что хранится под именем first. Для независимой копии объекта изучите clone и вложенные объекты.

<?php
declare(strict_types=1);
class CartLine
{
    public int $quantity = 2;
}
$line = new CartLine();
$quantity =& $line->quantity;
try {
    $quantity = 'many';
} catch (TypeError $error) {
    echo "Тип отклонён\n";
}
echo $line->quantity;

Тип отклонён
2

Некорректная запись не изменила свойство. readonly-свойства и свойства с hooks имеют дополнительные ограничения: не считайте, что любое выражение с -> можно безусловно связать через &.

<?php
$quantity = 2;
$data = ['shared' => &$quantity, 'plain' => 2];
$shared = ReflectionReference::fromArrayElement($data, 'shared');
$plain = ReflectionReference::fromArrayElement($data, 'plain');
var_dump($shared !== null);
var_dump($plain === null);

bool(true)
bool(true)

Оба элемента содержат число 2, но только shared связан с quantity. ===/!== сравнивают также тип. Наличие объекта ReflectionReference само не означает ошибку: ошибка появляется, если общее изменение противоречит вашему контракту.