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

<?php
$withDelivery = function ($price) {
    return $price + 50;
};
echo "Правило подготовлено\n";
$firstTotal = $withDelivery(150);
$secondTotal = $withDelivery(200);
echo 'Первый заказ: ', $firstTotal, ' руб.', "\n";
echo 'Второй заказ: ', $secondTotal, ' руб.', "\n";

Правило подготовлено
Первый заказ: 200 руб.
Второй заказ: 250 руб.

Создание функции не вычисляет сумму. Первый вызов получает 150, создаёт свой местный price=150 и возвращает 200 в firstTotal. Второй независимо получает 200 и возвращает 250 в secondTotal. Только внешние echo показывают обе суммы. Значение функции в PHP представлено объектом Closure; для этого первого вызова не требуется создавать собственный класс.

<?php
function prepareAmount($price, $calculate) {
    $amount = $calculate($price);
    return 'К оплате: ' . $amount . ' руб.';
}
$rule = function ($price) {
    return $price + 50;
};
$message = prepareAmount(150, $rule);
echo $message, "\n";

К оплате: 200 руб.

Внешний вызов передаёт price=150 и саму функцию rule в параметр calculate. Вызов calculate(150) входит в анонимную функцию; её return 200 возвращается в местное amount функции prepareAmount. Затем второй return возвращает строку «К оплате: 200 руб.» в message. Echo читает эту строку. Если вместо rule передать rule(150), получатель получил бы число 200 и не смог бы вызвать его.

<?php
$delivery = 50;
$oldRule = function ($price) use ($delivery) {
    return $price + $delivery;
};
$delivery = 100;
$newRule = function ($price) use ($delivery) {
    return $price + $delivery;
};
echo 'Прежнее правило для 150: ', $oldRule(150), ' руб.', "\n";
echo 'Новое правило для 150: ', $newRule(150), ' руб.', "\n";

Прежнее правило для 150: 200 руб.
Новое правило для 150: 250 руб.

OldRule создаётся при delivery=50 и сохраняет именно это число. Внешнее присваивание 100 не меняет его окружение. NewRule создаётся позже и сохраняет 100. Оба вызова получают один аргумент 150, но складывают с разными сохранёнными настройками. Use не создаёт глобальную переменную. Проще всего мыслить это как правило плюс его снимок числовых настроек; для объектов такая модель требует уточнения ниже.

<?php
function makeSkuFormatter($prefix) {
    return function ($sku) use ($prefix,): string {
        return $prefix . trim($sku);
    };
}
$format = makeSkuFormatter('SHOP-');
$prefix = 'OTHER-';
echo $format(' TEA '), "\n";
echo $format instanceof Closure ? "Это Closure\n" : "Другой тип\n";

$processed = 0;
$remember = function () use (&$processed) {
    ++$processed;
};
$remember();
$remember();
echo 'Обработано: ', $processed, "\n";

SHOP-TEA
Это Closure
Обработано: 2

prefix захвачен при создании, поэтому поздняя одноимённая переменная снаружи не заменяет SHOP-. Возвращённое замыкание живёт и после завершения makeSkuFormatter. В счётчике use(&$processed) намеренно разделяет изменяемую переменную. Тип возврата : string у анонимной функции записывается после use(...).

<?php
class ExportLabel {
    private string $prefix = 'EXPORT-';
    public function formatter(): Closure {
        return function (string $sku): string {
            return $this->prefix . $sku;
        };
    }
    public function independent(): Closure {
        return static function (string $sku): string {
            return (isset($this) ? 'object:' : 'no-this:') . $sku;
        };
    }
}
$labels = new ExportLabel();
$bound = $labels->formatter();
$independent = $labels->independent();
echo $bound('TEA'), "\n";
echo $independent('TEA'), "\n";

EXPORT-TEA
no-this:TEA

В обычном замыкании метода доступен текущий $this: оно хранит связь с объектом. static-замыкание её не получает. Это полезно для независимого callback, который не должен держать объект ради вычисления. static здесь не создаёт глобальную функцию или общий кэш.

<?php
$fee = 50;
$withFee = fn($amount) => $amount + $fee;
$fee = 99;
$payable = $withFee(100);
echo 'Сумма с сохранённой доставкой: ', $payable, ' руб.', "\n";

Сумма с сохранённой доставкой: 150 руб.

Fn начинает стрелочную функцию, скобки перечисляют параметр amount, а => вводит единственное возвращаемое выражение. Return не пишется. Использованная внешняя fee автоматически сохранена со значением 50, когда создавалась функция. Вызов передаёт 100, получает 150 и сохраняет его в payable. Этот => принадлежит синтаксису fn; это не пара ключ/значение массива.

<?php
$factory = fn($prefix) => fn($sku) => $prefix . $sku;
$shopFormat = $factory('SHOP-');
$label = $shopFormat('TEA');
echo 'Этикетка: ', $label, "\n";

Этикетка: SHOP-TEA

Первая стрелка возвращает значение выражения fn($sku)..., то есть новую функцию, а не строку. Вызов factory(SHOP-) сохраняет prefix внутри этой новой функции и присваивает её shopFormat. Только следующий вызов shopFormat(TEA) получает sku и возвращает строку SHOP-TEA в label. Это короткая запись уже изученной фабрики; при сложной логике её раскрывают через function/use/return.

<?php
$count = 0;
$localIncrease = fn() => ++$count;
$inside = $localIncrease();
echo 'Результат выражения: ', $inside, '; внешний счётчик: ', $count, "\n";
$increase = fn(&$value) => ++$value;
$increase($count);
echo 'После явного изменения параметра: ', $count, "\n";

Результат выражения: 1; внешний счётчик: 0
После явного изменения параметра: 1

Первая стрелка захватила count по значению; её ++ вернул 1, но внешний count остался 0. Во второй & относится к объявленному параметру value. Аргумент count связывается с ним на время вызова; ++ действительно меняет внешнюю переменную на 1. Автоматический захват и явный параметр по ссылке — разные механизмы. Для обычного подсчёта в цикле явное count++ снаружи понятнее.

<?php
function formatSku(string $sku): string {
    echo 'Форматируем ', $sku, "\n";
    return '[' . $sku . ']';
}
$format = formatSku(...);
echo "Форматтер сохранён\n";
$label = $format('TEA');
echo 'Этикетка: ', $label, "\n";
$equivalent = Closure::fromCallable('formatSku');
$secondLabel = $equivalent('MILK');
echo 'Вторая этикетка: ', $secondLabel, "\n";

Форматтер сохранён
Форматируем TEA
Этикетка: [TEA]
Форматируем MILK
Вторая этикетка: [MILK]

В записи formatSku(...) три точки — буквальный синтаксис PHP 8.1+, создающий Closure, без вызова тела. Поэтому первой видна строка «Форматтер сохранён». Вызов format(TEA) выводит диагностическую строку из тела и возвращает [TEA] в label. Closure::fromCallable — метод встроенного класса, создающий соответствующий обработчик по имени. Он вызван через :: без собственного объекта. Второй обработчик получает MILK и возвращает [MILK] в secondLabel. Диагностический echo показывает момент выполнения тела; в прикладном форматтере его обычно убирают.

<?php
$length = strlen(...);
$names = ['TEA', 'COFFEE'];
$lengths = array_map($length, $names);
foreach ($lengths as $position => $bytes) {
    echo $names[$position], ': ', $bytes, ' байт', "\n";
}

TEA: 3 байт
COFFEE: 6 байт

Length хранит вызываемую strlen. Array_map сам вызывает её с TEA, затем COFFEE и собирает возвращённые 3 и 6 в lengths. Это длина в байтах; здесь ASCII, поэтому совпадает с количеством букв. Следующий foreach соединяет каждое число с исходным названием той же позиции. Передача length без скобок даёт правило; вызов length(TEA) дал бы лишь одно число.

<?php
class ImportFormatter {
    private function format(string $sku): string {
        return 'IMPORT:' . $sku;
    }
    public function callback(): Closure {
        return $this->format(...);
    }
    public function oldStyle(): array {
        return [$this, 'format'];
    }
}
$formatter = new ImportFormatter();
$callback = $formatter->callback();
echo $callback('TEA'), "\n";
$old = $formatter->oldStyle();
try {
    $old('TEA');
} catch (Error $error) {
    echo "Массив не перенёс право доступа к private\n";
}

IMPORT:TEA
Массив не перенёс право доступа к private

Метод callback намеренно выдаёт возможность конкретного вызова, созданную в разрешённой области класса. Массив лишь хранит объект и имя; проверка доступа при внешнем вызове не разрешает private. Это не способ произвольно обходить область видимости чужого объекта.

<?php
// PHP 8.5+.
function prepareLabel(string $sku, Closure $format = static function (string $value): string {
    return '[' . $value . ']';
}): string {
    return $format($sku);
}
$normal = prepareLabel('TEA');
$custom = prepareLabel('TEA', function ($value) { return 'SHOP-' . $value; });
echo 'Стандарт: ', $normal, "\n";
echo 'Своё правило: ', $custom, "\n";

Стандарт: [TEA]
Своё правило: SHOP-TEA

В первом вызове второй аргумент опущен, поэтому параметр format получает стандартную Closure. Тело prepareLabel вызывает её с TEA; внутренний return даёт [TEA], внешний возвращает ту же строку в normal. Во втором вызове явное правило заменяет default и возвращает SHOP-TEA в custom. Тип Closure означает именно объект замыкания, не любую строку с именем функции. Для PHP 8.2–8.4 стандартное правило можно создать в теле после явного nullable-параметра.

<?php
// PHP 8.5+.
function bracketSku(string $sku): string {
    return '[' . $sku . ']';
}
const DEFAULT_LABEL = bracketSku(...);
$formatter = DEFAULT_LABEL;
$label = $formatter('COFFEE');
echo 'Этикетка: ', $label, "\n";

Этикетка: [COFFEE]

Const объявляет именованное неизменяемое значение DEFAULT_LABEL. BracketSku(...) создаёт вызываемое значение, а не строку этикетки. Обычное присваивание берёт его в formatter; только formatter(COFFEE) выполняет тело и возвращает [COFFEE]. Нельзя заменить bracketSku на произвольное выражение имени внутри этого константного синтаксиса. В версиях до 8.5 то же правило храните обычной переменной после объявления функции.

<?php
function describeCall($sku = 'TEA', $quantity = 1) {
    $count = func_num_args();
    $first = $count > 0 ? func_get_arg(0) : '(нет)';
    return $count . '|' . $first . '|'
        . json_encode(func_get_args(), JSON_THROW_ON_ERROR);
}
echo describeCall(), "\n";
echo describeCall('COFFEE', 2, 'legacy-extra'), "\n";
echo describeCall(quantity: 3), "\n";

0|(нет)|[]
3|COFFEE|["COFFEE",2,"legacy-extra"]
2|TEA|["TEA",3]

В пользовательскую функцию могут попасть дополнительные позиционные аргументы, даже когда их нет в сигнатуре; старый код исследует их этими функциями. Именованный quantity учитывает заполненный предыдущий default, как позиционная раскладка. Поэтому func_num_args — не универсальный способ выяснить, какие именно имена написал вызывающий. Для нового API яснее явные параметры и ...$rest.

<?php
function discountCalculator(int $percent): Closure {
    if ($percent < 0 || $percent > 100) {
        throw new InvalidArgumentException('Процент вне диапазона');
    }
    return function (int $kopecks) use ($percent): int {
        $discount = intdiv($kopecks * $percent, 100);
        return $kopecks - $discount;
    };
}
$springPrice = discountCalculator(15);
$regularPrice = discountCalculator(0);
$price = $springPrice(10000);
echo 'Со скидкой: ', $price, ' коп.', "\n";
echo 'Со скидкой и доставкой 500: ', $price + 500, ' коп.', "\n";
echo 'Без скидки: ', $regularPrice(10000), ' коп.', "\n";

Со скидкой: 8500 коп.
Со скидкой и доставкой 500: 9000 коп.
Без скидки: 10000 коп.

DiscountCalculator(15) проверяет процент и возвращает Closure со снимком 15 в springPrice. Цены в этот момент ещё нет. SpringPrice(10000) вызывает уже эту функцию: intdiv(10000*15,100)=1500, внутренний return даёт 8500. Оно сохраняется в price и участвует в следующем расчёте 8500+500. Другой экземпляр хранит 0 и возвращает 10000. Intdiv — целочисленное деление: здесь договор округляет скидку вниз для неотрицательных копеек; реальные правила округления выбирают отдельно.

<?php
$limit = 10;
$snapshot = function () use ($limit) { return $limit; };
$live = function () use (&$limit) { return $limit; };
$limit = 20;
echo 'Лимит старого правила: ', $snapshot(), "\n";
echo 'Текущий общий лимит: ', $live(), "\n";
$requested = 15;
if ($requested <= $live()) { echo "Заявка на 15 принята текущим правилом\n"; }

Лимит старого правила: 10
Текущий общий лимит: 20
Заявка на 15 принята текущим правилом

Snapshot сохранил число 10; live через use(&$limit) сохраняет связь с внешней переменной. Поэтому после присваивания 20 они возвращают разные числа. Return live() поступает прямо в сравнение 15<=20 и разрешает сообщение. Ссылка полезна только при намеренно общей изменяемой настройке; для независимых правил используйте снимки. Пустые скобки означают, что новых аргументов у этих вызовов нет.

<?php
declare(strict_types=1);

$products = [
    ['sku' => 'B', 'stock' => 2],
    ['sku' => 'A', 'stock' => 2],
    ['sku' => 'C', 'stock' => 0],
];
usort($products, static fn (array $a, array $b): int =>
    ($b['stock'] <=> $a['stock']) ?: ($a['sku'] <=> $b['sku'])
);
echo implode(',', array_column($products, 'sku')), "\n";

A,B,C

Компаратор возвращает отрицательное, ноль или положительное число, а не bool. Сначала убывание остатка, при равенстве артикул дает предсказуемый порядок. usort изменяет массив и перенумеровывает ключи; если ключи — ID, нужен uasort либо явный список ID.

<?php
$label = function ($number) {
    return 'Заказ №' . $number;
};
echo $label(41), "\n";
echo $label(52), "\n";
var_dump($label instanceof Closure);

Заказ №41
Заказ №52
bool(true)

function без имени создаёт анонимную функцию; $number — её входной параметр. Точка соединяет строки, return отдаёт результат. Скобки после переменной выполняют вызов. instanceof задаёт вопрос о классе объекта; true означает «да». У объекта есть тело функции, а у переменной — возможность обратиться к этому объекту. Сохранение не создаёт поток или фоновую задачу.

<?php
class Parcel { public $number; }
$first = new Parcel;
$first->number = 41;
$second = new Parcel;
$second->number = 52;
$prefix = 'Посылка №';
$template = function () use ($prefix) {
    return $prefix . $this->number;
};
$firstLabel = $template->bindTo($first, null);
$secondLabel = $template->bindTo($second, null);
echo $firstLabel(), "\n", $secondLabel(), "\n";

Посылка №41
Посылка №52

Здесь известное не-static тело и пользовательские объекты с public-свойством: обе привязки допустимы. null вторым аргументом не выдаёт права класса Parcel. Объекты не клонируются; обе новые функции имеют одинаковый текст, но разный $this. Исходный $template по-прежнему без объекта. В библиотеке с неизвестным входом результат привязки надо проверить на null; контракт показан ниже.

<?php
declare(strict_types=1);

class Exporter
{
    public Closure $format;
}
$exporter = new Exporter;
$exporter->format = static fn($number) => 'Заказ №' . $number;
echo ($exporter->format)(41), "\n";
var_dump(method_exists($exporter, 'format'));

Заказ №41
bool(false)

Внешние скобки сначала читают свойство, следующие вызывают хранящуюся в нём функцию. $exporter->format(41) означает поиск метода и здесь не подходит. public в этом учебном шаге делает замену видимой; в настоящем экспортёре обычно принимают callback через конструктор и хранят private. __call ради этой одной операции не нужен.

<?php
declare(strict_types=1);

$format = static fn($number) => 'Заказ №' . $number;
try {
    serialize($format);
} catch (Exception $error) {
    echo "Closure не сериализуется\n";
}
$job = ['action' => 'order-label', 'order_id' => 41];
$actions = ['order-label' => $format];
echo $actions[$job['action']]($job['order_id']), "\n";

Closure не сериализуется
Заказ №41

Встроенный serialize не сериализует Closure и выбрасывает Exception. Здесь задание — локальный заранее известный массив. В очереди сохраняют проверенные данные и идентификатор разрешённой операции; после чтения проверяют схему, наличие action в allowlist, права и тип order_id. Имя PHP-функции из внешнего JSON нельзя прямо превращать в callback. Пример не содержит очереди, хранения или доставки.

<?php
declare(strict_types=1);

$journal = new stdClass;
$journal->count = 0;
$next = static function () use ($journal) {
    static $local = 0;
    ++$journal->count;
    return ++$local;
};
echo $next(), "\n";
$copy = clone $next;
echo $next(), ':', $copy(), "\n";
echo $journal->count, "\n";
var_dump($copy === $next);

1
2:2
3
bool(false)

У этой настоящей анонимной функции clone создаёт отдельный Closure и копирует текущее собственное static-состояние: оба счётчика продолжили с 1 до 2. Захваченный объект журнала общий, поэтому его count стал 3. Это не глубокое копирование. Захват через use (&$variable) также оставляет общую ссылку. Для Closure, полученного из именованной функции, её static-переменные принадлежат исходной функции; не переносите на такой адаптер вывод об отдельном счётчике.

<?php
declare(strict_types=1);

class Labeler
{
    public function text() { return 'Заказ'; }
}
$labeler = new Labeler;
$observer = WeakReference::create($labeler);
$callback = Closure::fromCallable([$labeler, 'text']);
unset($labeler);
var_dump($observer->get() !== null);
echo $callback(), "\n";
unset($callback);
var_dump($observer->get() === null);

bool(true)
Заказ
bool(true)

WeakReference наблюдает объект, не удерживая его. Единственная сильная связь после unset($labeler) здесь находится в callback. Когда удалён и callback, объект освобождён. В реальном приложении могут быть другие ссылки и циклы; пример не обещает освобождение сразу после любого unset. Для длительно живущего worker не храните ненужные callback с большим окружением.

<?php
declare(strict_types=1);

$format = static function ($number, $prefix = 'Заказ') {
    return $prefix . ' №' . $number;
};
$info = new ReflectionFunction($format);
echo 'Обязательных: ', $info->getNumberOfRequiredParameters(), "\n";
echo 'Всего: ', $info->getNumberOfParameters(), "\n";
var_dump($info->getClosureThis() === null);
var_dump($info->isClosure());

Обязательных: 1
Всего: 2
bool(true)
bool(true)

ReflectionFunction получает описание действия. Он не вызывает тело и не показывает историю прежних вызовов. Один параметр обязателен, второй имеет значение по умолчанию; у static-функции нет $this. Для проверки совместимости конкретного callback одних количеств недостаточно: важны типы, ссылки, variadic и смысл аргументов.