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

<?php
declare(strict_types=1);

class ProductCard
{
    public string $title = 'Чай';
}
$card = new ProductCard();
echo $card->title, "\n";
$card->title = 'Зелёный чай';
echo $card->title, "\n";

Чай
Зелёный чай

Свойство title относится к объекту. $card — переменная, содержащая этот объект; имя свойства после -> пишется без $. Строка присваивания меняет значение, а echo только читает. Описание класса осталось прежним.

<?php
declare(strict_types=1);

class ProductCard
{
    public string $title = 'Чай';
    public function label(): string
    {
        return 'Товар: ' . $this->title;
    }
}
$card = new ProductCard();
echo $card->label(), "\n";
$card->title = 'Кофе';
echo $card->label(), "\n";

Товар: Чай
Товар: Кофе

function внутри класса объявляет метод. Пустые () означают, что дополнительных аргументов нет. $this появляется при вызове метода у объекта и указывает на него. Каждый вызов читает текущее title: label не является заранее сохранённой второй копией текста.

<?php
declare(strict_types=1);

class ProductCard
{
    public string $title = 'Чай';
}
$first = new ProductCard();
$second = new ProductCard();
$same = $first;
$same->title = 'Кофе';
echo 'Первая: ', $first->title, "\n";
echo 'Вторая: ', $second->title, "\n";

Первая: Кофе
Вторая: Чай

Два new создали две карточки. Присваивание $same = $first сохранило доступ к уже существующей первой карточке. Поэтому запись через $same видна через $first. Это правило объектов; оно не означает, что переменные связаны оператором &.

<?php
declare(strict_types=1);

class ProductCard
{
    public string $title;
}
$card = new ProductCard();
try {
    echo $card->title;
} catch (Error $error) {
    echo "Сначала задайте название.\n";
}
$card->title = 'Чай';
echo $card->title, "\n";

Сначала задайте название.
Чай

try выполняет действие, которое может не удасться; catch перехватывает Error от чтения незаполненного типизированного свойства. Так диагностируют проблему, но удобнее обязать передать название конструктору. Запись ?string допускает null, однако сама по себе тоже не устанавливает начальное значение.

<?php
declare(strict_types=1);

class ProductCard
{
    public string $title = 'Чай';
    public function rename(string $newTitle): void
    {
        $this->title = $newTitle;
    }
}
$card = new ProductCard();
$card->rename('Чёрный чай');
echo $card->title, "\n";

Чёрный чай

Чёрный чай передаётся в локальный параметр $newTitle. $this->title — поле объекта, $newTitle — временное имя входа в текущем вызове. void означает отсутствие возвращаемого значения; полезное действие — изменение названия.

<?php
declare(strict_types=1);

class OrderView
{
    public function __construct(public int $id, public string $status) {}
}

$first = new OrderView(7, 'new');
$second = new OrderView(7, 'new');
$alias = $first;
echo $first == $second ? "Данные равны\n" : "Данные различаются\n";
echo $first === $second ? "Один экземпляр\n" : "Два экземпляра\n";
echo $first === $alias ? "Alias ведёт к первому\n" : "Другая карточка\n";

$second->status = 'paid';
echo $first == $second ? "Данные равны\n" : "Данные различаются\n";
echo $first->id === $second->id ? "Один ID заказа\n" : "Разные ID\n";

Данные равны
Два экземпляра
Alias ведёт к первому
Данные различаются
Один ID заказа

Изменение second не затронуло first: они созданы разными new. Сравнение ID продолжает находить ту же запись, хотя её снимки расходятся. Сам ID не выбирает, какая версия новее; для конкурентного сохранения нужна версия/транзакция хранилища.

<?php
declare(strict_types=1);

class ImportProduct
{
    public string $title = 'Старое';
}

$warnings = [];
set_error_handler(function (int $level, string $message) use (&$warnings): bool {
    if ($level !== E_DEPRECATED) {
        return false;
    }
    $warnings[] = 'Обнаружено устаревшее создание свойства';
    return true;
});
try {
    $product = new ImportProduct();
    $product->titel = 'Новое';
} finally {
    restore_error_handler();
}
echo $warnings[0], "\n";
echo 'Объявленное поле: ', $product->title, "\n";
echo 'Ошибочное поле: ', $product->titel, "\n";
$product->title = 'Новое';
echo 'После исправления: ', $product->title, "\n";

Обнаружено устаревшее создание свойства
Объявленное поле: Старое
Ошибочное поле: Новое
После исправления: Новое

Обработчик временный и ограничен учебным блоком; finally восстанавливает прежний. Use (&$warnings) позволяет обработчику добавить запись в тот же массив — механизм объяснён в главе ссылок. Мы не выводим внутренний текст предупреждения, содержащий путь файла. На будущей версии, меняющей динамические свойства, поведение нужно сверить заново.

<?php
declare(strict_types=1);

interface TitleSource
{
    public function titles(): array;
}

function reportTitles(TitleSource $source): string
{
    return implode(', ', $source->titles());
}

$source = new class(['Чай', 'Кофе']) implements TitleSource {
    private array $titles;

    public function __construct(array $titles)
    {
        $this->titles = $titles;
    }

    public function titles(): array
    {
        return $this->titles;
    }
};

echo reportTitles($source), "\n";
echo $source instanceof TitleSource ? "Договор выполнен\n" : "Другой тип\n";

Чай, Кофе
Договор выполнен

Аргумент после class передаётся конструктору. Implements имеет тот же смысл, что у именованного класса. Внешняя функция получает обычный объект интерфейсного типа; автоматической загрузки названий и скрытого HTTP здесь нет.

<?php
declare(strict_types=1);

class AuthorCard
{
    public string $title;
    public function __construct(string $title) { $this->title = $title; }
}
class LoadCounter { public int $count = 0; }

$counter = new LoadCounter();
$reflection = new ReflectionClass(AuthorCard::class);
$card = $reflection->newLazyGhost(function (AuthorCard $card) use ($counter): void {
    $counter->count++;
    $card->__construct('Редактор каталога');
});
echo 'До чтения: ', $counter->count, "\n";
echo $card->title, "\n";
echo $card->title, "\n";
echo 'После чтений: ', $counter->count, "\n";

До чтения: 0
Редактор каталога
Редактор каталога
После чтений: 1

NewLazyGhost не вызывает наш обычный конструктор автоматически. Callback здесь сознательно вызывает __construct для заполнения текущего объекта. Обычное new AuthorCard всё ещё работает немедленно; в ленивой схеме момент подготовки изменён инфраструктурой.

<?php
declare(strict_types=1);

class ProfileCard
{
    public function __construct(public string $title) {}
}

$real = new ProfileCard('Первая подпись');
$reflection = new ReflectionClass(ProfileCard::class);
$proxy = $reflection->newLazyProxy(function (ProfileCard $proxy) use ($real): ProfileCard {
    return $real;
});
echo $proxy->title, "\n";
echo $proxy === $real ? "Один экземпляр\n" : "Разные экземпляры\n";
$proxy->title = 'Изменено через proxy';
echo $real->title, "\n";

Первая подпись
Разные экземпляры
Изменено через proxy

Для ясности настоящая карточка создана заранее; практическая фабрика может получить её позднее. После инициализации proxy перенаправляет доступ к real, но не становится тем же экземпляром по ===. Поэтому кэш, построенный на идентичности объектов, должен учитывать выбранную стратегию.

<?php
declare(strict_types=1);

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

class DeliveryCustomer
{
    public function __construct(public ?DeliveryAddress $address) {}
}

$customers = [
    null,
    new DeliveryCustomer(null),
    new DeliveryCustomer(new DeliveryAddress('Москва')),
];

foreach ($customers as $customer) {
    echo $customer?->address?->city ?? 'Город не указан';
    echo "\n";
}

Город не указан
Город не указан
Москва

Вопросительный знак перед DeliveryAddress в типе разрешает объект или null. Вопросительный знак в ?-> относится уже к операции чтения. Мы поставили его в обеих точках возможного отсутствия: клиент и адрес. Само имя поля city и его существование оператор не проверяет за модель.

<?php
declare(strict_types=1);

interface SummaryRenderer
{
    public function render(): string;
}

class CsvSummary implements SummaryRenderer
{
    public function render(): string { return 'id;title'; }
}

class JsonSummary implements SummaryRenderer
{
    public function render(): string { return '{"id":42}'; }
}

$allowed = ['csv' => CsvSummary::class, 'json' => JsonSummary::class];
$selected = 'csv';
$className = $allowed[$selected] ?? throw new InvalidArgumentException('Неизвестный формат');
$renderer = new $className();
echo $renderer::class, "\n";
echo $renderer->render(), "\n";
$another = new $renderer();
echo $another === $renderer ? "Тот же объект\n" : "Новый объект того же класса\n";

CsvSummary
id;title
Новый объект того же класса

::class у уже существующего объекта сообщает его фактический класс. New $renderer() использует класс этого объекта, но создаёт новый экземпляр: состояние прежнего не копируется. Здесь конструкторов нет; если бы конструктор требовал настройки, их пришлось бы передать и при таком создании.

<?php
declare(strict_types=1);

class ReportCaption
{
    public function __construct(private string $month) {}
    public function text(): string { return 'Отчёт: ' . $this->month; }
}

echo (new ReportCaption('октябрь'))->text(), "\n";
echo new ReportCaption('октябрь')->text(), "\n";

Отчёт: октябрь
Отчёт: октябрь

Весь этот пример требует PHP 8.4 из-за второй строки. Первая форма с внешними скобками работает в базовом PHP 8.2: скобки явно объединяют создание объекта перед ->. Обе записи вызывают конструктор и затем один метод; более короткая форма не делает объект постоянным между HTTP-запросами.

<?php
declare(strict_types=1);

class ReportView
{
    public string $title = 'Сырые данные';
    public Closure $formatter;

    public function __construct()
    {
        $this->formatter = fn (string $text): string => '[' . $text . ']';
    }

    public function title(): string
    {
        return 'Готовый отчёт';
    }
}

$view = new ReportView();
echo $view->title, "\n";
echo $view->title(), "\n";
echo ($view->formatter)('Заказы'), "\n";

Сырые данные
Готовый отчёт
[Заказы]

У formatter нет объявленного метода. Внешние скобки в ($view->formatter) сначала получают объект Closure из свойства, а следующие запускают его с текстом. Запись $view->formatter() искала бы метод formatter. Тип Closure разрешён для свойства; тип callable для свойства не поддерживается.

<?php
namespace ReportDemo;

class CsvReport
{
    public function header(): string { return 'id;title'; }
}

Это сопутствующий файл следующего исполняемого примера. Сохраните его как CsvReport.php в той же папке; namespace является частью полного имени класса.

<?php
declare(strict_types=1);

$first = function (string $name): void {
    echo "Первый загрузчик пропустил имя\n";
};
$second = function (string $name): void {
    if ($name === 'ReportDemo\\CsvReport') {
        require __DIR__ . '/CsvReport.php';
        echo "Второй загрузчик подключил файл\n";
    }
};
spl_autoload_register($first);
spl_autoload_register($second);
try {
    $name = ReportDemo\CsvReport::class;
    echo class_exists($name, false) ? "Класс уже загружен\n" : "Есть имя, объявления ещё нет\n";
    $report = new $name();
    echo $report->header(), "\n";
    echo class_exists($name, false) ? "Теперь объявление есть\n" : "Нет объявления\n";
} finally {
    spl_autoload_unregister($first);
    spl_autoload_unregister($second);
}

Есть имя, объявления ещё нет
Первый загрузчик пропустил имя
Второй загрузчик подключил файл
id;title
Теперь объявление есть

В class_exists второй аргумент false запрещает запуск загрузки: это чистая проверка уже известных объявлений. Само ::class даёт строку. Загрузчики работают при new, а не при регистрации. После опыта они снимаются с очереди, чтобы не вмешиваться в другую программу.

<?php
declare(strict_types=1);

$laterCalls = 0;
$broken = function (string $name): void {
    throw new RuntimeException('Учебный сбой загрузчика');
};
$later = function (string $name) use (&$laterCalls): void {
    $laterCalls++;
};
spl_autoload_register($broken);
spl_autoload_register($later);
try {
    try {
        new MissingReportDemo();
    } catch (RuntimeException $error) {
        echo "Сбой прервал загрузку\n";
    }
    echo 'Вызовов следующего: ', $laterCalls, "\n";
} finally {
    spl_autoload_unregister($broken);
    spl_autoload_unregister($later);
}

Сбой прервал загрузку
Вызовов следующего: 0

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

<?php
declare(strict_types=1);

readonly class OrderNumberView
{
    public function __construct(public string $number) {}
}

trait HasOrderCaption
{
    public function caption(): string
    {
        return 'Заказ ' . $this->number;
    }
}

$view = new readonly class('ORD-42') extends OrderNumberView {
    use HasOrderCaption;
};
echo $view->caption(), "\n";
try {
    $view->number = 'ORD-43';
} catch (Error $error) {
    echo "Номер уже задан\n";
}

Заказ ORD-42
Номер уже задан

Анонимный readonly-класс доступен с PHP 8.3; обычный readonly-класс — с PHP 8.2. Родитель тоже readonly, а трейт не приносит несовместимых свойств. Поскольку дочерний конструктор не объявлен, используется унаследованный.

<?php
declare(strict_types=1);

class LazyProduct
{
    public int $id;
    public string $source = 'catalog';
    public string $title;
}

$loads = 0;
$class = new ReflectionClass(LazyProduct::class);
$product = $class->newLazyGhost(static function (LazyProduct $product) use (&$loads): void {
    ++$loads;
    $product->title = 'Товар ' . $product->id;
});
$class->getProperty('id')->setRawValueWithoutLazyInitialization($product, 42);
$class->getProperty('source')->skipLazyInitialization($product);
echo $product->id, ': ', $product->source, '; загрузок ', $loads, "\n";
echo $product->title, '; загрузок ', $loads, "\n";
echo $product->title, '; загрузок ', $loads, "\n";

42: catalog; загрузок 0
Товар 42; загрузок 1
Товар 42; загрузок 1

В initializer нет сети: это счётчик и формирование строки. В реальном репозитории тут могла бы быть загрузка из БД с обработкой отсутствия строки. Вызов без состояния, например метод, возвращающий имя класса, сам по себе не обязан инициализировать объект. Если исключить из ленивости последнее ленивое поле, PHP больше не будет хранить ожидающий initializer.

<?php
declare(strict_types=1);

class ProductCaption
{
    public function __construct(public string $title) {}
}

$class = new ReflectionClass(ProductCaption::class);
$ghost = $class->newLazyGhost(static function (ProductCaption $object): void {
    $object->__construct('Ghost-карточка');
});
$proxy = $class->newLazyProxy(static fn (): ProductCaption => new ProductCaption('Proxy-карточка'));
$readyGhost = $class->initializeLazyObject($ghost);
$real = $class->initializeLazyObject($proxy);
echo $readyGhost === $ghost ? "Ghost остался собой\n" : "Иной объект\n";
echo $real === $proxy ? "Одинаковая идентичность\n" : "Proxy и real различаются\n";
$real->title = 'Обновлённая карточка';
echo $proxy->title, "\n";

Ghost остался собой
Proxy и real различаются
Обновлённая карточка

InitializeLazyObject вызывает штатную инициализацию. Для ghost возвращается тот же объект, для proxy — лежащий за ним реальный. Повторная инициализация готового объекта ничего не запускает заново; это отличается от reset.

<?php
declare(strict_types=1);

class RetryCaption
{
    public string $title;
}

$attempts = 0;
$class = new ReflectionClass(RetryCaption::class);
$caption = $class->newLazyGhost(static function (RetryCaption $caption) use (&$attempts): void {
    ++$attempts;
    $caption->title = 'Промежуточное значение';
    if ($attempts === 1) { throw new RuntimeException('Данные ещё не доступны'); }
    $caption->title = 'Готовый отчёт';
});
try { echo $caption->title; } catch (RuntimeException $error) { echo "Первая попытка не готова\n"; }
echo $class->isUninitializedLazyObject($caption) ? "Снова lazy\n" : "Уже готов\n";
echo array_key_exists('title', get_mangled_object_vars($caption)) ? "Поле осталось\n" : "Поле откатилось\n";
echo 'Попыток снаружи: ', $attempts, "\n";
echo $caption->title, '; попыток ', $attempts, "\n";

Первая попытка не готова
Снова lazy
Поле откатилось
Попыток снаружи: 1
Готовый отчёт; попыток 2

Get_mangled_object_vars здесь только проверяет своё публичное поле и не инициирует новую загрузку. Счётчик доказывает отсутствие общей транзакции. Для платежа повтор initializer недопустимо считать гарантированно безопасным: нужен отдельный протокол идемпотентности и сверки исхода.

<?php
declare(strict_types=1);

class CountedCaption
{
    public static int $copies = 0;
    public static int $released = 0;
    public function __construct(public string $title) {}
    public function __clone(): void { ++self::$copies; }
    public function __destruct() { ++self::$released; }
}

$class = new ReflectionClass(CountedCaption::class);
$unused = $class->newLazyGhost(static function (CountedCaption $object): void {
    $object->__construct('Не запрашивали');
});
unset($unused);
echo 'Освобождено без загрузки: ', CountedCaption::$released, "\n";
$loads = 0;
$proxy = $class->newLazyProxy(static function () use (&$loads): CountedCaption {
    ++$loads;
    return new CountedCaption('Исходная подпись');
});
$copy = clone $proxy;
$copy->title = 'Подпись копии';
echo $proxy->title, ' / ', $copy->title, "\n";
echo 'Загрузок: ', $loads, '; копий: ', CountedCaption::$copies, "\n";
unset($proxy, $copy);
echo 'Освобождено после работы: ', CountedCaption::$released, "\n";

Освобождено без загрузки: 0
Исходная подпись / Подпись копии
Загрузок: 1; копий: 1
Освобождено после работы: 2

Нет отдельного третьего деструктора для обёртки proxy: деструктор принадлежит реальному экземпляру. Если другая переменная держала бы real, он продолжал бы жить после unset(proxy). Копирование вложенных объектов по-прежнему поверхностное, если __clone не задаёт другой порядок.

<?php
declare(strict_types=1);

class ResettableCaption
{
    public function __construct(public string $title) {}
}

$caption = new ResettableCaption('A');
$alias = $caption;
$class = new ReflectionClass(ResettableCaption::class);
$class->resetAsLazyGhost($caption, static function (ResettableCaption $object): void {
    $object->__construct('B');
});
echo $caption === $alias ? "Ссылка сохранилась\n" : "Новый объект\n";
echo $alias->title, "\n";
$class->resetAsLazyProxy($caption, static fn (): ResettableCaption => new ResettableCaption('C'));
$real = $class->initializeLazyObject($caption);
echo $caption === $alias ? "Обёртка та же\n" : "Обёртка другая\n";
echo $real === $caption ? "Real совпал\n" : "Real отдельный\n";
echo $alias->title, "\n";

Ссылка сохранилась
B
Обёртка та же
Real отдельный
C

Класс примера не владеет внешним ресурсом. У реального объекта нужно сначала понять его инварианты и ответственность деструктора. Reset не предназначен для ещё не инициализированного lazy-объекта; во время инициализации или перебора его свойств действуют дополнительные ограничения.

<?php
declare(strict_types=1);

class ManualCaption
{
    public string $title;
    public string $format = 'text';
}

$calls = 0;
$class = new ReflectionClass(ManualCaption::class);
$caption = $class->newLazyGhost(static function (ManualCaption $object) use (&$calls): void {
    ++$calls;
    $object->title = 'Автоматическая подпись';
});
$class->markLazyObjectAsInitialized($caption);
echo 'Вызовов initializer: ', $calls, "\n";
echo 'Формат: ', $caption->format, "\n";
try { echo $caption->title; } catch (Error $error) { echo "Title ещё не заполнен\n"; }
$caption->title = 'Ручная подпись';
echo $caption->title, "\n";

Вызовов initializer: 0
Формат: text
Title ещё не заполнен
Ручная подпись

MarkLazyObjectAsInitialized снимает ленивость без вызова callback. Объявленный default format появился, но обязательный title остался uninitialized. Это инструмент для слоя, который сам восстановит корректное состояние, а не замена initializeLazyObject.

<?php
declare(strict_types=1);

readonly class OrderSnapshot
{
    public function __construct(public array $items) {}
}

$class = new ReflectionClass(OrderSnapshot::class);
$snapshot = $class->newLazyGhost(static function (OrderSnapshot $snapshot): void {
    $snapshot->__construct(['P-42']);
});
echo $class->isUninitializedLazyObject($snapshot) ? "До чтения: lazy\n" : "Уже готов\n";
echo 'Позиций: ', count($snapshot->items), "\n";
try { $snapshot->items[] = 'P-43'; } catch (Error $error) { echo "Снимок нельзя дополнить\n"; }
echo implode(', ', $snapshot->items), "\n";

До чтения: lazy
Позиций: 1
Снимок нельзя дополнить
P-42

Массив заполнен один раз. Если элементом был бы изменяемый объект, его внутреннее состояние readonly-класс не сделал бы автоматически неизменяемым. Об этом отдельно в разделе о поверхностной неизменяемости.

<?php
declare(strict_types=1);

class BaseProduct
{
    public function __construct(public string $title) {}
}
class ProductProxy extends BaseProduct {}
class ExtendedProxy extends BaseProduct
{
    public string $extra = 'Дополнительное поле';
}

$class = new ReflectionClass(ProductProxy::class);
$proxy = $class->newLazyProxy(static fn (): BaseProduct => new BaseProduct('Товар P-42'));
echo $proxy->title, "\n";
echo get_class($proxy), ' / ', get_class($class->initializeLazyObject($proxy)), "\n";
$incompatibleClass = new ReflectionClass(ExtendedProxy::class);
$incompatible = $incompatibleClass->newLazyProxy(static fn (): BaseProduct => new BaseProduct('P-43'));
try { echo $incompatible->title; } catch (Error $error) { echo "Лишнее поле proxy несовместимо\n"; }

Товар P-42
ProductProxy / BaseProduct
Лишнее поле proxy несовместимо

Обычный безопасный договор — factory возвращает готовый экземпляр того же класса. Разрешён и показанный случай: класс proxy — потомок класса real, без дополнительных свойств и без переопределения __clone/__destruct. Это не произвольная взаимозаменяемость любых родителей и потомков.