TeoreticQuiz

PHP

Материал для подготовки к собеседованию (Middle / Senior). Термины на английском там, где это принято.

Содержание


Типы данных и переменные

Скалярные типы: bool, int, float, string. Составные: array, object, callable, iterable. Специальные: null, resource. Псевдотипы для сигнатур: void, never, mixed, self, static, false, true.

PHP — язык с динамической, но постепенно усиливающейся типизацией. Типы можно объявлять для аргументов, свойств и возвращаемых значений.

Передача по значению и по ссылке, copy-on-write

Скаляры и массивы передаются по значению, объекты — по значению дескриптора (по сути ссылка на тот же объект в памяти).

function addSca(int $x) { $x++; }        // копия, снаружи не изменится
function addRef(int &$x) { $x++; }        // & — по ссылке, изменит оригинал

$obj = new Foo();
function mutate(Foo $f) { $f->x = 1; }    // объект изменится: передан тот же инстанс

Массивы работают по механизму copy-on-write: пока копию не изменяют, обе переменные указывают на одни данные, реальное копирование происходит только при записи. Это экономит память.

Приведение типов и сравнения

  • == — нестрогое сравнение (с приведением типов), === — строгое (тип + значение).
  • В PHP 8 поведение == для строк и чисел стало логичнее: 0 == "foo" теперь false (в PHP 7 было true).
  • Оператор spaceship <=> возвращает -1/0/1 — удобно для сортировок.
  • Null coalescing ?? и ??= — значение по умолчанию, если переменная не задана или null.
$name = $data['name'] ?? 'guest';
$config['ttl'] ??= 3600;

Строгая типизация и контракты типов

declare(strict_types=1);

Запрещает автоматическое приведение примитивов в сигнатурах: при несоответствии типа бросается TypeError. Помогает ловить ошибки раньше. Важно: директива действует только в том файле, где объявлена (влияет на вызовы из этого файла, а не на вызываемый код).

Тип — это контракт. Средства уточнения контракта:

  • Nullable ?T — значение либо T, либо null.
  • Union types int|string (8.0) — одно из нескольких.
  • Intersection types Countable&Traversable (8.1) — одновременно несколько интерфейсов.
  • Псевдотипы never (функция не возвращает управление), void, mixed, self, static.

Ковариантность и контравариантность (LSP на уровне типов, PHP 7.4). Наследник может сузить возвращаемый тип (ковариантность) и расширить тип аргумента (контравариантность), не нарушая совместимости с базовым контрактом:

class AnimalShelter {
    public function adopt(): Animal { /* ... */ }
}
class CatShelter extends AnimalShelter {
    public function adopt(): Cat { /* ... */ }   // ковариантность: Cat — подтип Animal
}

Деструктуризация массива

[$foo, $bar, $baz] = ['foo', 'bar', 'baz'];
[, , $baz] = $source_array;                 // пропуск элементов
['baz' => $three] = ['foo' => 1, 'baz' => 3]; // по ключу

[$a, $b] = [$b, $a];                        // обмен значений без временной переменной

Variadic-функции и распаковка аргументов

Variadic-функция принимает переменное число аргументов через ... — они собираются в массив. Это типобезопасная замена устаревшему func_get_args(), т.к. позволяет объявить тип элементов.

function sum(int ...$numbers): int {
    return array_sum($numbers);   // $numbers — массив int
}
sum(1, 2, 3);        // 6
sum();               // 0 (можно ноль аргументов)

Можно комбинировать с обычными параметрами (variadic — всегда последний):

function log(string $level, string ...$messages): void { /* ... */ }

Распаковка (spread) ... — обратная операция: разворачивает массив/Traversable в список аргументов при вызове, а также объединяет массивы (с 8.1 — и со строковыми ключами):

$args = [1, 2, 3];
sum(...$args);                       // распаковка в аргументы

$merged = [...$arr1, ...$arr2];      // объединение массивов

Именованные аргументы тоже распаковываются из ассоциативного массива: foo(...['age' => 30, 'name' => 'John']).

Область видимости: global и static

global связывает переменную из глобальной области с локальной; альтернатива — суперглобальный $GLOBALS.

$a = 1; $b = 2;
function sum() { global $a, $b; $b = $a + $b; }
sum(); echo $b; // 3

Статическая переменная функции сохраняет значение между вызовами:

function test() { static $a = 0; echo $a; $a++; }

Использование global в приложении считается антипаттерном (скрытые зависимости) — предпочтительнее DI.


Подключение файлов: include / require

  • include — при отсутствии файла бросает warning, выполнение продолжается.
  • require — при отсутствии файла бросает fatal error, выполнение прерывается.
  • Суффикс _once (include_once / require_once) — файл подключится только один раз.

В современных проектах ручные подключения почти не используются — их заменяет автозагрузка через Composer.


ООП

Четыре принципа

  • Инкапсуляция — сокрытие реализации, доступ через модификаторы public, protected, private.
  • Наследование — создание нового класса на базе существующего (extends).
  • Полиморфизм — единый интерфейс, разные реализации. В PHP реализуется через переопределение методов (override) и позднее связывание. Классической перегрузки методов (несколько методов с одним именем и разными сигнатурами) в PHP нет — «overloading» в документации PHP означает магические методы (__call, __get и т.п.).
  • Абстракция — выделение существенного и сокрытие деталей реализации.

Модификаторы доступа и асимметричная видимость

public / protected / private. С PHP 8.4 доступна асимметричная видимость — разный уровень для чтения и записи:

public function __construct(
    public private(set) string $title,   // читать можно всем, писать — только внутри класса
    public protected(set) string $author,
    protected private(set) int $pubYear,
) {}

Множественное наследование и трейты

Множественного наследования классов в PHP нет — заменяется трейтами и интерфейсами. Конфликты трейтов разрешаются через insteadof и as:

use A, B {
    B::smallTalk insteadof A;   // берём реализацию из B
    A::bigTalk insteadof B;
    B::bigTalk as talk;         // алиас
}

Интерфейсы vs абстрактные классы

Интерфейс Абстрактный класс
Методы только сигнатуры (public) любые, в т.ч. с реализацией
Свойства нет (с PHP 8.4 — абстрактные свойства с hooks: public string $name { get; }) есть
Константы да (с PHP 8.1 можно final, типизированные — 8.3) да
Множественность класс реализует много интерфейсов наследуется только один класс
Создание объекта нельзя нельзя

Интерфейс отвечает на вопрос «что умеет», абстрактный класс — «что умеет + частичная реализация».

final

Ключевое слово final перед методом/свойством/константой запрещает переопределение в наследниках; перед классом — запрещает наследование вообще.

Позднее статическое связывание: self vs static

  • self:: — ссылается на класс, в котором физически написан код (разрешается на этапе компиляции, фиксирован).
  • static:: — позднее статическое связывание: ссылается на класс, который реально вызван в рантайме.
class Model {
    public static string $connection = 'mysql';
    public function make(): void { echo self::$connection; }   // всегда mysql
    public function make2(): void { echo static::$connection; } // зависит от вызвавшего класса
}
class User extends Model { public static string $connection = 'postgres'; }

(new User())->make();  // mysql  (self)
(new User())->make2(); // postgres (static)

Магические методы

Вызываются автоматически в определённых ситуациях: __construct, __destruct, __get/__set/__isset/__unset (обращение к недоступным свойствам), __call/__callStatic (недоступные методы), __invoke (вызов объекта как функции), __toString, __clone, __sleep/__wakeup и __serialize/__unserialize.

Constructor Property Promotion (PHP 8.0)

Объявление и инициализация свойств прямо в конструкторе:

class User {
    public function __construct(
        public string $name,
        public int $age = 18,
    ) {}
}

readonly и enum

readonly class Point { public function __construct(public int $x, public int $y) {} } // 8.2

enum Status: string {
    case Active = 'active';
    case Banned = 'banned';
    public function label(): string { return ucfirst($this->value); }
}

readonly-свойства (8.1) можно задать один раз; readonly-классы (8.2) делают такими все свойства — удобно для value objects и DTO. Enum (8.1) бывают чистыми и типизированными (backed), могут иметь методы и реализовывать интерфейсы.

Анонимные функции, замыкания и callable

Анонимная функция (closure) — функция без имени, объект класса Closure. Передаётся в параметры типа callable, захватывает переменные через use.

$mul = 3;
$fn = fn(int $x) => $x * $mul;   // arrow fn — автозахват по значению
$fn2 = function (int $x) use ($mul) { return $x * $mul; };

Первоклассный синтаксис вызова (PHP 8.1) — ссылка на функцию/метод как значение:

$fn = strtoupper(...);
$fn = $service->handle(...);

Анонимные классы (PHP 7.0):

$obj = new class { public function hello() { return 'Hello!'; } };

Трейты

Трейт (trait) — механизм горизонтального переиспользования кода: набор методов (и свойств), которые можно «подмешать» в любой класс. Решает отсутствие множественного наследования: класс наследует только один класс, но может использовать много трейтов.

trait Loggable {
    public function log(string $msg): void {
        echo static::class . ": $msg";
    }
}

trait Timestampable {
    protected ?\DateTimeImmutable $createdAt = null;
    public function touch(): void { $this->createdAt = new \DateTimeImmutable(); }
}

class Order {
    use Loggable, Timestampable;   // подмешиваем оба трейта
}

(new Order())->log('создан');

Ключевые моменты:

  • Трейт — не тип: нельзя сделать new Trait или type-hint по трейту (для этого — интерфейсы). Частый приём — трейт + интерфейс (интерфейс задаёт контракт, трейт даёт реализацию).
  • Могут содержать абстрактные методы (обязать класс их реализовать), статические методы/свойства, константы (с PHP 8.2).
  • Приоритет при конфликте имён: метод самого класса > метод трейта > унаследованный метод.

Разрешение конфликтов — если два трейта дают метод с одним именем, используют insteadof (выбрать чей) и as (алиас / смена видимости):

trait A { public function hello() { echo 'A'; } public function bye() { echo 'A-bye'; } }
trait B { public function hello() { echo 'B'; } }

class C {
    use A, B {
        B::hello insteadof A;   // берём hello из B
        A::hello as helloFromA; // а метод A доступен под алиасом
        A::bye as protected;    // сменить видимость
    }
}

Трейт vs абстрактный класс vs интерфейс: интерфейс — контракт «что умеет» (без реализации, можно много); абстрактный класс — «что умеет + частичная реализация» (наследуется один, есть состояние/конструктор, отношение «is-a»); трейт — переиспользование реализации без наследования (отношение «умеет делать», можно много). Минус трейтов — «спрятанные» зависимости и сложность отслеживания, откуда метод; злоупотреблять не стоит.


Исключения и ошибки

С PHP 7 ошибки и исключения приведены к общей иерархии интерфейса Throwable:

Throwable
├── Error          (внутренние ошибки движка: TypeError, ValueError, DivisionByZeroError, ...)
└── Exception      (прикладные исключения: RuntimeException, LogicException, ...)
  • Error — ошибки уровня движка (несовпадение типов, обращение к несуществующему методу). Их обычно не ловят, а исправляют код.
  • Exception — предсказуемые прикладные ситуации, которые можно и нужно обрабатывать.
  • Ловить можно по Throwable, если нужно перехватить и то и другое.
try {
    // ...
} catch (RuntimeException | LogicException $e) {   // множественный catch (7.1)
    log($e);
} finally {
    cleanup();
}

Хорошие практики: не глотать исключения молча, использовать специфичные типы, сохранять исходное исключение через previous, не использовать исключения для управления обычным потоком.


Генераторы и итераторы

Итераторы

Итерируемое (Traversable) — то, что можно перебрать в foreach: массивы и объекты, реализующие Iterator или IteratorAggregate.

Итератор — объект, реализующий интерфейс Iterator (5 методов: current(), key(), next(), rewind(), valid()). Позволяет foreach работать с любым объектом, а не только с массивом, и отдавать значения по одному (лениво).

class RangeIterator implements Iterator {
    private int $cur;
    public function __construct(private int $start, private int $end) { $this->cur = $start; }
    public function rewind(): void  { $this->cur = $this->start; }   // в начало
    public function valid(): bool   { return $this->cur <= $this->end; } // есть ли ещё
    public function current(): int  { return $this->cur; }           // текущее значение
    public function key(): int      { return $this->cur - $this->start; } // ключ
    public function next(): void    { $this->cur++; }                // шаг вперёд
}
foreach (new RangeIterator(1, 3) as $k => $v) { echo "$k=>$v "; } // 0=>1 1=>2 2=>3

Писать полный Iterator вручную многословно — чаще берут IteratorAggregate (один метод getIterator(), внутри — yield или готовый итератор) или сразу генераторы.

Генераторы

Генератор — функция с оператором yield. Вместо возврата одного значения она отдаёт значения по мере необходимости, не загружая всю коллекцию в память (ленивые, потоковые вычисления). Под капотом генератор автоматически реализует Iterator.

function genOneToThree() {
    for ($i = 1; $i <= 3; $i++) {
        yield $i;                 // «приостановить и отдать значение»
    }
}
foreach (genOneToThree() as $value) { echo "$value\n"; }

Как работает: при вызове функции-генератора код не выполняется сразу — возвращается объект Generator. Тело выполняется по кусочкам: доходит до yield, отдаёт значение и замораживается, при следующем запросе (next()/следующая итерация foreach) — продолжает с того же места. Состояние (локальные переменные) сохраняется между yield.

Ключи и значения — можно отдавать пары:

function pairs() {
    yield 'a' => 1;
    yield 'b' => 2;
}
foreach (pairs() as $k => $v) { echo "$k=$v "; } // a=1 b=2

Методы объекта Generator: current(), key(), next(), valid(), rewind() (как у итератора) + send() и getReturn() (ниже). Генератор однопроходный — его нельзя перемотать в начало и пройти повторно (rewind после старта бросит ошибку); для повторного прохода — вызвать функцию заново.

Ленивое чтение большого файла (классический пример — почему генераторы экономят память):

function readLines(string $file) {
    $h = fopen($file, 'r');
    try {
        while (($line = fgets($h)) !== false) {
            yield rtrim($line);      // строки отдаются по одной, файл не грузится целиком
        }
    } finally {
        fclose($h);                  // finally гарантирует закрытие даже при прерывании
    }
}
foreach (readLines('huge.log') as $line) { /* обработать */ }

yield from (делегирование)

yield from делегирует генерацию другому генератору, массиву или Traversable — «вставляет» его значения в текущий генератор, не переписывая цикл вручную. Удобно для композиции генераторов и обхода вложенных/рекурсивных структур.

function inner() {
    yield 1;
    yield 2;
}
function outer() {
    yield 0;
    yield from inner();      // подставит 1, 2
    yield from [3, 4];       // можно и массив/Traversable
    yield 5;
}
foreach (outer() as $v) { echo "$v "; }  // 0 1 2 3 4 5

Важные нюансы yield from:

  • Сохраняет ключи вложенного генератора/массива (в отличие от простого разворачивания) — при числовых ключах это может дать «дубли» ключей; для последовательных значений это обычно не важно.
  • Пробрасывает return вложенного генератора: yield from возвращает значение, которое вложенный генератор вернул через return — можно собирать результаты.
  • Незаменим для рекурсивных генераторов (обход дерева):
function walkTree(array $node) {
    yield $node['value'];
    foreach ($node['children'] ?? [] as $child) {
        yield from walkTree($child);   // рекурсивный обход без сбора всего в память
    }
}

return и send

return в генераторе завершает его и задаёт «итоговое» значение (не попадает в foreach), доступное через getReturn() после окончания перебора:

function gen() {
    yield 1;
    yield 2;
    return 'done';
}
$g = gen();
foreach ($g as $v) { echo "$v "; }  // 1 2
echo $g->getReturn();               // done

send() — двусторонняя связь: передать значение внутрь генератора (там yield вернёт его). Так генератор становится «сопрограммой» (корутиной) — на этом строятся событийные библиотеки и Fibers-подобные приёмы:

function echoTimes() {
    while (true) {
        $received = yield;          // yield как выражение — получает то, что передали в send()
        echo "получено: $received\n";
    }
}
$g = echoTimes();
$g->current();        // «прокрутить» до первого yield
$g->send('hello');   // получено: hello
$g->send('world');   // получено: world

Итог: генераторы дают ленивые последовательности с минимальным потреблением памяти (большие файлы, выборки БД, бесконечные последовательности), yield from — композицию и рекурсию, send/return/getReturn — продвинутые сценарии (корутины, сбор итога). Ограничение — однопроходность и то, что это не «настоящая» асинхронность (для неё — Fibers/Swoole).


Управление памятью и сборка мусора

Память в PHP управляется автоматически — разработчик не освобождает её вручную. Разберём, как это устроено.

zval и подсчёт ссылок

Каждое значение в PHP хранится во внутренней структуре zval (тип + собственно значение + служебные поля). У «сложных» значений (объекты, массивы, строки при копировании) есть счётчик ссылок (refcount) — сколько переменных/ссылок указывают на это значение.

  • Присваивание переменной увеличивает refcount, выход переменной из области видимости или unset() — уменьшает.
  • Когда refcount падает до 0 — значение сразу освобождается (память возвращается).
$a = new Foo();   // refcount у объекта = 1
$b = $a;          // refcount = 2 (обе переменные — на один объект)
unset($a);        // refcount = 1
unset($b);        // refcount = 0 → объект уничтожается (вызывается __destruct)

Это основной механизм — большинство объектов удаляется мгновенно по счётчику, без участия «настоящего» сборщика мусора.

Copy-on-write (COW)

Массивы и строки копируются по механизму copy-on-write: при присваивании данные физически не копируются — обе переменные ссылаются на один zval (refcount растёт). Реальное копирование происходит только при первой записи в одну из копий.

$a = range(1, 1000000);  // большой массив
$b = $a;                 // НЕ копируется — общий zval (быстро, память не растёт)
$b[0] = 99;              // вот теперь массив копируется (COW-разрыв)

Экономит память и время; отсюда же — почему передача массива в функцию «по значению» дёшева, пока функция его не меняет.

Циклические ссылки и mark-and-sweep

Проблема подсчёта ссылок — циклические ссылки: объекты ссылаются друг на друга, поэтому их refcount никогда не станет 0, даже когда снаружи на них уже никто не ссылается.

class Node { public ?Node $ref = null; }
$a = new Node();
$b = new Node();
$a->ref = $b;
$b->ref = $a;         // цикл: a→b→a
unset($a, $b);        // снаружи ссылок нет, но refcount каждого = 1 (друг на друга)
// по счётчику они НЕ удалятся — это «мусор в цикле»

Для таких случаев есть сборщик циклического мусора на алгоритме mark-and-sweep (точнее — алгоритм обнаружения циклов Bacon–Rajan). Как работает:

  1. Значения, у которых refcount уменьшился, но не до нуля, попадают в корневой буфер (root buffer) — кандидаты на цикл.
  2. Когда буфер заполняется (по умолчанию 10 000 возможных корней), запускается сбор: алгоритм помечает достижимое от «настоящих» корней и определяет группы, замкнутые сами на себя (недостижимые снаружи).
  3. Такие циклы освобождаются.

Ручное управление:

gc_enable();          // включить сборщик циклов (включён по умолчанию)
gc_disable();         // отключить (иногда для коротких CLI-скриптов ради скорости)
gc_collect_cycles();  // принудительно запустить сбор сейчас (вернёт число освобождённых)
gc_status();          // статистика (runs, collected, roots, ...) — PHP 7.3+

Сбор недёшев (проход по буферу), поэтому запускается не на каждое уменьшение счётчика, а по заполнении буфера; в некоторых сценариях (жёсткий real-time участок) его временно отключают.

__destruct и утечки

__destruct() вызывается при уничтожении объекта (когда refcount→0 или при сборе цикла) — там закрывают ресурсы (файлы, соединения). Нюанс: в циклах порядок вызова деструкторов не гарантирован; в конце запроса деструкторы тоже вызываются при разрушении.

«Утечки» в PHP в классическом смысле редки из-за shared-nothing (память освобождается в конце запроса), но реальны в долгоживущих процессах (CLI-воркеры очередей, Swoole/RoadRunner):

  • Растущие статические свойства/массивы, глобальные кэши без ограничения размера.
  • Незакрытые ресурсы, накопление объектов в контейнере.
  • Циклы при отключённом GC.

Средства: следить за memory_get_usage() / memory_get_peak_usage(), перезапускать воркер после N задач (--max-jobs, pm.max_requests в FPM), ограничивать кэши, не держать лишних ссылок. Лимит на процесс — memory_limit (при превышении — фатальная ошибка).

WeakReference и WeakMap

Иногда нужно сослаться на объект, не мешая его удалению по счётчику ссылок:

  • WeakReference (PHP 7.4) — слабая ссылка: не увеличивает refcount, get() вернёт объект или null, если он уже уничтожен.
  • WeakMap (PHP 8.0) — карта «объект → данные» со слабыми ключами: когда объект-ключ уничтожается, запись автоматически удаляется. Идеально для кэша/метаданных, привязанных к объектам, без риска утечки (обычный массив/SplObjectStorage держал бы объект «сильной» ссылкой и мешал бы его удалению).
$cache = new WeakMap();
$cache[$user] = computeProfile($user);  // пока жив $user — данные в кэше
// как только на $user не останется других ссылок — запись из WeakMap исчезнет сама

Модель shared-nothing

В вебе PHP работает по модели shared-nothing: каждый запрос обрабатывается изолированно, память запроса выделяется заново и в конце запроса вся освобождается — состояние между запросами по умолчанию не сохраняется. Следствия: утечка в рамках одного запроса не фатальна (всё равно освободится в конце), данные между запросами хранят во внешних хранилищах (сессии/БД/Redis), это упрощает горизонтальное масштабирование. Исключение — резидентные раннеры (Swoole/RoadRunner/FrankenPHP), где процесс живёт долго и за памятью надо следить.


Пространства имён и автозагрузка

Пространства имён (namespace) решают конфликты имён классов и организуют код. Импорт — через use (с алиасами use ... as ...).

Разработчики договорились хранить один класс в одном файле. Чтобы не писать длинные списки require, используется автозагрузка: spl_autoload_register() регистрирует функцию(и), которые подгружают классы при первом обращении.

spl_autoload_register(function ($class) { include $class . '.php'; });
$obj = new MyClass1(); // файл подключится автоматически

На практике автозагрузку обеспечивает Composer по стандарту PSR-4.


Composer

Пакетный менеджер для управления зависимостями (реестр — packagist.org).

  • composer install — ставит версии, зафиксированные в composer.lock (или создаёт lock по composer.json, если его нет).
  • composer update — пересчитывает и обновляет версии в рамках ограничений composer.json, обновляя composer.lock.
  • composer.lock фиксирует точные версии всех пакетов — гарантирует одинаковое окружение у всей команды и на проде.
  • После установки генерируется vendor/autoload.php для подключения зависимостей.

Типы автозагрузки: psr-4 (по неймспейсам), classmap (скан каталогов), files (принудительное подключение — например, файлы с функциями-хелперами). Семантика версий: ^ (совместимые в рамках мажорной), ~ (в рамках минорной), точные версии.


Reflection API

Интроспекция кода во время выполнения: узнать о классе его свойства, методы, константы, атрибуты, параметры конструктора и их типы; при необходимости обращаться к приватным членам и вызывать их.

$ref = new ReflectionClass(UserService::class);
foreach ($ref->getConstructor()->getParameters() as $p) {
    echo $p->getType() . ' $' . $p->getName() . "\n";  // разбор зависимостей
}
$method = $ref->getMethod('secret');
$method->invoke($userService);     // вызов private-метода; setAccessible(true) с PHP 8.1 не нужен

Где применяется: DI-контейнеры (автоматическое разрешение зависимостей по типам аргументов конструктора — так работает autowiring в Symfony/Laravel), чтение атрибутов (роуты, ORM-маппинг, валидация), сериализация, генерация прокси и моков в тестах. Рефлексия небыстрая — в проде её результаты кэшируют (compiled container).


SPL

Standard PHP Library — встроенный набор структур данных, итераторов, интерфейсов и функций для типовых задач без внешних зависимостей.

Структуры данных:

Класс Назначение
SplStack стек (LIFO) на двусвязном списке
SplQueue очередь (FIFO)
SplDoublyLinkedList двусвязный список
SplPriorityQueue очередь с приоритетами
SplFixedArray массив фиксированного размера с целыми ключами — быстрее и экономнее обычного массива на больших объёмах
SplObjectStorage множество/карта объектов (объект как ключ); используется для хранения уникальных объектов и привязки к ним данных
SplHeap / SplMinHeap / SplMaxHeap бинарная куча

Интерфейсы (позволяют своим классам вести себя как встроенные типы): Countable (count($obj)), ArrayAccess (доступ по []), Iterator / IteratorAggregate (обход в foreach), Traversable.

Итераторы: ArrayIterator, AppendIterator, LimitIterator, FilterIterator, RecursiveIteratorIterator (обход деревьев, например файловой системы через RecursiveDirectoryIterator).

Файлы: SplFileObject, SplFileInfo.

$storage = new SplObjectStorage();
$storage->attach($user, ['role' => 'admin']);  // объект + связанные данные
if ($storage->contains($user)) { $meta = $storage[$user]; }

Конкурентность, асинхронность и очереди

Модель выполнения

Классический PHP работает синхронно и блокирующе: один процесс (PHP-FPM worker) обрабатывает один запрос, ввод-вывод (БД, HTTP, файл) блокирует его до завершения. Параллелизм на уровне веб-сервера достигается процессами, а не потоками (shared-nothing): FPM держит пул воркеров, каждый обслуживает один запрос за раз.

Почему в PHP «нет асинхронности из коробки» как в Node.js: в PHP нет встроенного event loop, а модель shared-nothing и синхронные драйверы (PDO, mysqli) блокируют процесс на время I/O. Асинхронность добавляют расширения/библиотеки (ниже).

Различать понятия (частый вопрос):

  • Конкурентность (concurrency) — управление несколькими задачами, чередуя их (переключение во время ожидания I/O), в т.ч. на одном ядре. «Успевать много дел».
  • Параллелизм (parallelism) — одновременное выполнение на нескольких ядрах/потоках. «Делать много дел буквально в один момент».
  • Блокирующий vs неблокирующий I/O — при блокирующем процесс простаивает, ожидая завершения операции; при неблокирующем — может заняться другой задачей и вернуться, когда данные готовы.
  • Кооперативная vs вытесняющая многозадачность — при кооперативной задача сама «уступает» управление (yield/suspend), при вытесняющей планировщик прерывает её принудительно (настоящие потоки/процессы ОС).

Подходы к асинхронности

  • Fibers (PHP 8.1) — низкоуровневый примитив кооперативной многозадачности: выполнение можно приостановить (Fiber::suspend()) и позже возобновить ($fiber->resume()), сохранив состояние. Сами по себе Fibers не дают параллелизма и не делают I/O неблокирующим — это «строительный блок», на котором событийные библиотеки прячут then/await за синхронно выглядящим кодом.
$fiber = new Fiber(function (): void {
    echo "старт\n";
    $value = Fiber::suspend('приостановлено');   // отдать управление наружу
    echo "возобновлено с: $value\n";
});
$suspended = $fiber->start();   // "старт", вернёт 'приостановлено'
$fiber->resume('данные');       // "возобновлено с: данные"
  • ReactPHP — событийный цикл (event loop) и неблокирующий I/O, модель как у Node.js (промисы, потоки). Один процесс обслуживает много соединений конкурентно.
  • Swoole / OpenSwoole — расширение с корутинами и резидентным процессом: корутины дают конкурентность на неблокирующем I/O (переключение на await-подобных точках прозрачно), высокая производительность для real-time (WebSocket) и высоких нагрузок. Приложение живёт в памяти между запросами.
  • RoadRunner — application server на Go, держит PHP-воркеры резидентно (нет перезагрузки фреймворка на каждый запрос) — прирост скорости, но нужно следить за состоянием между запросами.
  • FrankenPHP — современный сервер приложений (на Go/Caddy) с резидентным режимом и поддержкой worker mode.
  • parallel (ext-parallel) — расширение для настоящих потоков (реальный параллелизм для CPU-bound задач); требует ZTS-сборку PHP.
  • pcntl (pcntl_fork) — форк процессов в CLI (не для веб-SAPI); для многопроцессных воркеров.
  • Фоновые задачи — быстрый способ: запуск через CLI (exec, shell_exec, proc_open), но правильнее — через очереди (ниже).

Важно на собеседовании: Fibers/Swoole/ReactPHP дают конкурентность (эффективное ожидание I/O в одном процессе), а настоящий параллелизм — это процессы (FPM/pcntl) или потоки (parallel).

Гонки и синхронизация

Как только появляется конкурентный доступ к общему ресурсу (счётчик в Redis, строка в БД, файл, баланс), возникают race conditions — результат зависит от порядка выполнения. Средства:

  • Блокировки БД — пессимистичные (SELECT ... FOR UPDATE — блокируем строку до конца транзакции) и оптимистичные (колонка версии/updated_at в WHERE; если 0 строк обновлено — кто-то опередил, повторяем).
  • Распределённые блокировки — Redis (SET key val NX PX 30000 — установить, только если нет, с TTL; паттерн Redlock), symfony/lock. Чтобы одну задачу не выполняли два воркера одновременно.
  • Атомарные операции — INCR/DECR в Redis, атомарные UPDATE ... SET x = x + 1 в SQL (вместо «прочитать → изменить → записать»).
  • Идемпотентность — обработчики очередей должны корректно переваривать повторную доставку одного сообщения (проверять по уникальному id), т.к. очереди дают at-least-once.

Очереди задач

Механизм асинхронной обработки: тяжёлое/долгое (отправка почты, генерация отчёта, обработка изображения) выносят из HTTP-запроса в фон — пользователю быстро отвечаем, а задача обрабатывается воркером позже. Плюсы: быстрый отклик, сглаживание пиков (буфер), отказоустойчивость (задача не потеряется), распределение нагрузки.

Схема: приложение кладёт задание (message) в очередь → воркер (отдельный долгоживущий процесс) забирает и выполняет → при ошибке — повтор (retry) с задержкой, после лимита — в «мёртвую» очередь (DLQ).

Транспорты:

  • RabbitMQ — брокер сообщений с гибкой маршрутизацией (в PHP — php-amqplib).
  • Redis — как очередь через списки (LPUSH/RPOP, надёжнее — LMOVE в processing-список) или Redis Streams.
  • Beanstalkd — простой сервер очередей (pda/pheanstalk).
  • Amazon SQS, Kafka (скорее лог событий, чем классическая очередь).
  • Фреймворки — Laravel Queues (+ Horizon для Redis-очередей) и Symfony Messenger дают высокоуровневый API поверх этих транспортов: диспетчеризация, ретраи, failed-очереди, несколько шин.

Важные моменты воркеров: запуск queue:work/messenger:consume под supervisor/systemd (перезапуск при падении); воркер долгоживущий — следить за утечками памяти (перезапуск после N задач); идемпотентность; обработка «ядовитых» сообщений через retry-лимит и DLQ (подробнее — раздел 11).


Сессии и куки

Сессии хранят данные пользователя на сервере между запросами (HTTP сам по себе stateless). Сервер создаёт уникальный session_id, отдаёт его клиенту (обычно в cookie PHPSESSID), а данные держит у себя в $_SESSION. На каждом запросе клиент присылает id → PHP находит по нему данные.

session_start();                    // старт/возобновление (до любого вывода!)
$_SESSION['user_id'] = 42;          // записать
$id = $_SESSION['user_id'] ?? null; // прочитать
unset($_SESSION['user_id']);        // удалить одно значение
session_destroy();                  // уничтожить сессию на сервере

Жизненный цикл: session_start() (при первом запросе генерирует id и шлёт Set-Cookie, при последующих — читает id из cookie и загружает данные) → чтение/запись $_SESSION → в конце запроса PHP сохраняет данные в хранилище. По умолчанию сессия блокируется на время запроса (см. ниже про session_write_close).

Параметры сессий

Настраиваются в php.ini, через ini_set() до session_start(), или массивом опций в session_start([...]). Самые важные:

Параметр Что делает
session.save_handler где хранить: files (по умолчанию), redis, memcached, свой
session.save_path путь/DSN хранилища (для files — каталог; для redis — tcp://host:port)
session.name имя cookie сессии (по умолчанию PHPSESSID)
session.gc_maxlifetime сколько секунд данные сессии живут на сервере без обращения (таймаут неактивности)
session.gc_probability / gc_divisor вероятность запуска сборщика мусора старых сессий (например, 1/100)
session.cookie_lifetime срок жизни cookie у клиента (0 — до закрытия браузера)
session.cookie_path / cookie_domain область действия cookie (путь/домен, для поддоменов)
session.cookie_httponly cookie недоступна из JS (document.cookie) — защита от кражи через XSS
session.cookie_secure cookie только по HTTPS
session.cookie_samesite Strict / Lax / None — отправка cookie в cross-site контексте (защита от CSRF)
session.use_strict_mode отклонять неинициализированные (чужие) session id — защита от session fixation
session.use_only_cookies запретить передачу id в URL (безопаснее; по умолчанию включено)
session.sid_length / sid_bits_per_character длина/энтропия session id
session_start([
    'cookie_httponly' => true,
    'cookie_secure'   => true,
    'cookie_samesite' => 'Lax',
    'gc_maxlifetime'  => 1800,   // 30 минут неактивности
    'use_strict_mode' => true,
]);

Важно про два «времени жизни»: cookie_lifetime — сколько cookie с id живёт в браузере; gc_maxlifetime — сколько данные сессии хранятся на сервере. Они независимы: если cookie ещё есть, а серверные данные удалены сборщиком мусора — сессия «протухла».

Хранилище сессий и масштабирование: по умолчанию files (файлы на диске одного сервера). При нескольких серверах за балансировщиком файловые сессии не работают (запрос может уйти на другой сервер) — используют общее хранилище: Redis/Memcached или БД (session.save_handler = redis, save_path = 'tcp://...'), либо sticky sessions на балансировщике.

Блокировка сессии (важный нюанс производительности): пока запрос держит открытую сессию, файл/ключ блокируется, и параллельные запросы того же пользователя (например, несколько AJAX) ждут. Если после чтения запись в сессию не нужна — вызвать session_write_close() раньше, чтобы освободить блокировку и не тормозить параллельные запросы.

Сессии vs куки

Сессии Куки
Где хранятся на сервере (клиенту — только id) в браузере клиента
Безопасность выше (данные не видны клиенту) ниже (клиент видит/меняет)
Срок жизни до gc_maxlifetime / закрытия браузера можно задать явно, переживает закрытие
Объём ограничен памятью/диском сервера ~4 КБ, только текст
Отправка id в cookie на каждый запрос всё содержимое на каждый запрос к домену

Работа с cookie напрямую — setcookie($name, $value, $options); чтение — суперглобаль $_COOKIE.

Cookie — это строка имя=значение + набор атрибутов, которые управляют её жизнью и безопасностью. Сервер задаёт их в заголовке Set-Cookie, браузер хранит и присылает обратно.

setcookie('token', $value, [
    'expires'  => time() + 3600,   // Unix-время истечения
    'path'     => '/',
    'domain'   => 'example.com',
    'secure'   => true,
    'httponly' => true,
    'samesite' => 'Lax',
]);
// Заголовок:
// Set-Cookie: token=...; expires=...; path=/; domain=example.com; secure; HttpOnly; SameSite=Lax

Разбор атрибутов:

Атрибут Что делает
HttpOnly Cookie недоступна из JavaScript (document.cookie её не видит). Главная защита от кражи cookie через XSS. Для cookie сессий/токенов — обязателен.
Secure Cookie отправляется только по HTTPS (не по http). Защита от перехвата в открытой сети.
SameSite Управляет отправкой cookie в межсайтовых (cross-site) запросах — защита от CSRF (подробно ниже).
Expires Дата/время истечения (абсолютное). Без Expires/Max-Age cookie — сессионная (живёт до закрытия браузера).
Max-Age Срок жизни в секундах (относительное, приоритетнее Expires в современных браузерах).
Domain Для какого домена cookie. Без него — только текущий хост; с Domain=example.com — и для поддоменов (app.example.com).
Path Для какого пути cookie отправляется (Path=/ — весь сайт, Path=/admin — только этот раздел).

SameSite подробнее (частый вопрос):

  • Strict — cookie не отправляется ни при каких переходах с других сайтов (даже по обычной ссылке). Максимально безопасно, но неудобно: перейдя на сайт по внешней ссылке, пользователь окажется «разлогинен» (cookie не ушла).
  • Lax (разумный дефолт, в браузерах — по умолчанию) — cookie отправляется при навигации верхнего уровня GET-переходом (клик по ссылке), но не при cross-site POST/fetch/загрузке в <img>/iframe. Баланс безопасности и удобства.
  • None — cookie отправляется всегда, включая cross-site запросы; обязательно вместе с Secure (иначе браузер отклонит). Нужно для сторонних cookie (встраиваемые виджеты, SSO, cross-origin API).

Первичные (first-party) vs сторонние (third-party) cookie: first-party — cookie того же сайта, что открыт в адресной строке; third-party — cookie другого домена (реклама, трекеры, встроенные виджеты). Браузеры всё жёстче ограничивают third-party cookie; для межсайтовых сценариев нужен SameSite=None; Secure.

Префиксы имён (доп. защита):

  • __Secure- — браузер примет cookie с таким именем, только если стоит Secure (и HTTPS).
  • __Host- — ещё строже: требует Secure, Path=/ и запрещает Domain (привязка к конкретному хосту, нельзя подменить с поддомена). Максимально безопасно для сессионных/CSRF-cookie.

Ограничения: размер одной cookie ~4 КБ; на домен — ограниченное число cookie; всё содержимое отправляется на сервер при каждом запросе к домену — поэтому в cookie не кладут много данных (для этого — сессии/localStorage).

Для cookie сессии те же атрибуты задаются через параметры session.cookie_* (см. таблицу выше) — под капотом PHP так же формирует Set-Cookie для PHPSESSID.

Защита сессий

  • HTTPS — шифрование трафика (иначе id можно перехватить).
  • session.cookie_httponly = 1 — cookie недоступна из JS (защита от кражи через XSS).
  • session.cookie_secure = 1 — cookie только по HTTPS.
  • session.cookie_samesite = Strict/Lax — защита от CSRF.
  • session.use_strict_mode = 1 — не принимать «чужой» неинициализированный id (защита от session fixation).
  • session_regenerate_id(true) — сменить id после логина и смены привилегий (главная защита от session fixation; true удаляет старую сессию).
  • Таймаут неактивности (gc_maxlifetime + свой контроль «последней активности»), валидация данных в $_SESSION, CSRF-токены для форм.
  • При logout — очистить $_SESSION = [], удалить cookie и session_destroy().

Безопасность

SQL-инъекции. Внедрение произвольного SQL. Защита: prepared statements через PDO/MySQLi (главное средство), параметризованные запросы; экранирование — вспомогательно.

$stmt = $pdo->prepare('SELECT * FROM users WHERE email = :email');
$stmt->execute(['email' => $email]);

XSS (Cross-Site Scripting). Вставка вредоносного JS в страницу. Защита: экранирование вывода htmlspecialchars() (с ENT_QUOTES), Content Security Policy.

CSRF (Cross-Site Request Forgery). Выполнение действия от имени аутентифицированного пользователя. Защита: уникальный CSRF-токен на форму и его проверка, SameSite-cookie, проверка заголовков.

Загрузка файлов. Белый список типов, проверка MIME и расширения, хранение вне webroot, генерация собственных имён.

Конфигурация. Отключить вывод ошибок на проде, ограничить доступ к .env и служебным файлам, держать ПО в актуальных версиях, не хранить секреты в репозитории.

CORS. Механизм, разрешающий/ограничивающий запросы к ресурсам с других источников (доменов) в обход политики одного источника (same-origin policy). Управляется заголовками Access-Control-Allow-Origin и др. на сервере. CORS — это не защита от XSS, а контроль межисточниковых запросов.

Обработка паролей

Пароли никогда не хранят в открытом виде, не шифруют обратимо и не хешируют быстрыми алгоритмами (md5, sha1) — их подбирают перебором. Используется медленный адаптивный хеш с солью.

  • password_hash($pwd, PASSWORD_DEFAULT) — генерирует соль автоматически и кладёт её вместе с алгоритмом и стоимостью в результат. Алгоритмы: PASSWORD_BCRYPT, PASSWORD_ARGON2ID (предпочтителен, устойчивее к GPU/ASIC).
  • password_verify($pwd, $hash) — сравнение за постоянное время (защита от timing-атак).
  • Cost / work factor — параметр сложности; повышают по мере роста мощности железа.
  • password_needs_rehash() — проверка, не устарели ли параметры хеша; при успешном логине можно прозрачно перехешировать.
  • Соль уже встроена в результат — отдельно хранить не нужно. Pepper (общий секрет вне БД) — опциональная доп. мера.
  • Для сравнения любых секретов/токенов вручную — hash_equals() (constant-time), не ==.
$hash = password_hash($password, PASSWORD_ARGON2ID);
if (password_verify($input, $hash)) {
    if (password_needs_rehash($hash, PASSWORD_ARGON2ID)) {
        $hash = password_hash($input, PASSWORD_ARGON2ID); // обновить и сохранить
    }
}

Аутентификация и управление доступом

  • Аутентификация (authentication) — «кто ты» (проверка личности: логин/пароль, токен, 2FA).
  • Авторизация (authorization) — «что тебе можно» (проверка прав на действие/ресурс). Это разные шаги: пройденная аутентификация не даёт доступ ко всему.

Модели авторизации:

  • RBAC (Role-Based Access Control) — права привязаны к ролям, роли — к пользователям (admin, editor, viewer). Просто и распространено.
  • ABAC (Attribute-Based) — решение по атрибутам субъекта, ресурса и контекста (например, «редактировать может только автор и только до публикации»). В Laravel — Policies/Gates, в Symfony — Voters.
  • ACL (Access Control List) — явные права на конкретный объект для конкретного субъекта.

Принципы security-by-design:

  • Least privilege — минимально необходимые права по умолчанию; расширять осознанно.
  • Deny by default — запрещено всё, что явно не разрешено.
  • Проверка доступа на сервере на каждый запрос, а не только скрытие кнопок в UI.
  • IDOR (Insecure Direct Object Reference) — всегда проверять, что запрошенный объект принадлежит текущему пользователю (WHERE user_id = :me), а не только что id существует.
  • Токены/сессии — HTTPS, короткое время жизни, ротация id, безопасное хранение, отзыв.
  • Секреты — в переменных окружения/секрет-хранилище, не в коде и не в репозитории.
  • Валидация и фильтрация всего ввода, доверять только серверной проверке.

Производительность

  • Профилирование — Xdebug, Blackfire, SPX — искать узкие места, а не оптимизировать вслепую.
  • OPcache — кэш скомпилированного байткода, убирает повторную компиляцию на каждом запросе (обязателен на проде).
  • JIT (PHP 8.0) — компиляция в машинный код; заметный выигрыш на CPU-bound задачах, для типичных веб-запросов эффект скромнее.
  • База данных — индексы, отказ от лишних запросов, борьба с N+1, prepared statements.
  • Кэширование — результатов запросов и вычислений (Redis/Memcached).
  • Оптимизация кода — убрать неиспользуемое, не тянуть тяжёлые зависимости без нужды.
  • Статика — gzip/brotli, минификация CSS/JS, оптимизация изображений.
  • preload (PHP 7.4) — предзагрузка классов в память при старте.

Кэширование

Хранение результатов вычислений или данных для ускорения будущего доступа и снятия нагрузки с медленных ресурсов (БД, внешние API).

  • Уровень приложения: Memcached (простой распределённый кэш в памяти), Redis (структуры данных, персистентность, pub/sub).
  • Уровень БД: кэш результатов запросов в памяти приложения (MySQL Query Cache удалён в 8.0 — полагаемся на внешний кэш).
  • HTTP-кэширование: заголовки Cache-Control, Expires, валидаторы ETag, Last-Modified.
  • Кэш представлений: результаты рендеринга шаблонов (Blade, Twig).
  • Файловый кэш: данные на диске для быстрого повторного доступа.

Отдельный вопрос — инвалидация: по TTL, по событию (при записи), по тегам.


Тестирование

Виды: модульное (unit — компонент в изоляции), интеграционное (взаимодействие модулей), функциональное (с точки зрения пользователя), нагрузочное, безопасности.

PHPUnit — основной фреймворк модульного тестирования. Тесты в каталоге tests, класс наследует PHPUnit\Framework\TestCase.

use PHPUnit\Framework\TestCase;

class MyTest extends TestCase {
    public function testAddition(): void {
        $this->assertEquals(2, 1 + 1);
    }
}
  • Mock — фиктивный объект тестируемого взаимодействия, на котором проверяют факт и параметры вызова (проверка поведения).
  • Stub — заглушка зависимости, возвращающая заранее заданные данные (подмена состояния).

Ориентир — пирамида тестов: много быстрых unit, меньше интеграционных, ещё меньше e2e.


Стандарты PSR

PSR (PHP Standards Recommendations) от PHP-FIG обеспечивают совместимость фреймворков и библиотек.

  • PSR-1 — базовый стандарт кода (открывающий тег, именование классов/методов).
  • PSR-3 — интерфейс логгера.
  • PSR-4 — автозагрузка по неймспейсам (используется Composer).
  • PSR-7 — интерфейсы HTTP-сообщений (request/response).
  • PSR-11 — контейнер внедрения зависимостей.
  • PSR-12 — расширенный стайл-гайд (заменил устаревший PSR-2).
  • PSR-15 — HTTP middleware.

Следование стандартам упрощает поддержку и совместимость. Инструменты: PHP_CodeSniffer, PHP-CS-Fixer.


Принципы и паттерны

Общие принципы

  • YAGNI — не пишите код «на будущее», пока он реально не нужен.
  • DRY — не дублируйте логику: дубли дороже в поддержке и опаснее при изменениях.
  • KISS — простое решение надёжнее; не усложняйте без необходимости.
  • Big Design Up Front / Avoid Premature Optimization — продумать архитектуру заранее, но не оптимизировать до того, как доказана необходимость.

SOLID

  • SRP — у класса одна ответственность и одна причина для изменения.
  • OCP — открыт для расширения, закрыт для модификации (через абстракции).
  • LSP — объект наследника заменяет объект базового класса без нарушения корректности.
  • ISP — много узких интерфейсов лучше одного «толстого»; клиент не зависит от того, чем не пользуется.
  • DIP — зависимость от абстракций, а не от конкретных реализаций; детали зависят от абстракций.

DTO (Data Transfer Object)

Объект для передачи данных между слоями (контроллер → сервис → хранилище). Обычно класс с публичными (часто readonly) свойствами. Снижает связанность, делает контракт данных явным.

final class UserDTO {
    public function __construct(
        public readonly int $id,
        public readonly string $name,
        public readonly string $email,
    ) {}
}

DTO — это «мешок данных» без поведения; его задача — перенос, а не гарантия корректности.

Value Object (VO)

Объект, который определяется своими значениями, а не идентичностью (в отличие от Entity, у которой есть id). Ключевые свойства:

  • Иммутабельность — после создания не меняется; «изменение» возвращает новый экземпляр.
  • Самовалидация — некорректный VO невозможно создать (валидация в конструкторе). Это переносит контракт из «где-то в сервисе» внутрь типа.
  • Равенство по значению — два VO с одинаковыми данными равны.
  • Инкапсуляция поведения предметной области (например, Money::add()).
final readonly class Email {
    public function __construct(public string $value) {
        if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
            throw new InvalidArgumentException("Некорректный email: $value");
        }
    }
    public function equals(self $other): bool { return $this->value === $other->value; }
}

Зачем на собеседовании это важно: VO делает невалидные состояния непредставимыми — вместо string $email, который может быть чем угодно, метод принимает тип Email, гарантированно валидный. Это и есть «типы как контракты». DTO переносит данные между слоями, VO — гарантирует их корректность и смысл внутри домена.

Смежное — Dependency Injection (внедрение зависимостей через конструктор вместо создания внутри), которое опирается на контракты-интерфейсы (DIP из SOLID).


PDO и работа с БД

PDO (PHP Data Objects) — единый объектный интерфейс доступа к разным СУБД (MySQL, PostgreSQL, SQLite и др.). Меняешь драйвер в DSN — код запросов почти не меняется (в отличие от старого mysqli, привязанного к MySQL).

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

$dsn = 'mysql:host=localhost;dbname=shop;charset=utf8mb4';
$pdo = new PDO($dsn, $user, $pass, [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,   // ошибки как исключения (дефолт с PHP 8.0, явно — для наглядности)
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,          // строки как ассоц. массивы
    PDO::ATTR_EMULATE_PREPARES   => false,                     // настоящие prepared statements
]);

Prepared statements (подготовленные выражения) — главная защита от SQL-инъекций: данные передаются отдельно от SQL, а не склеиваются в строку.

// Именованные плейсхолдеры
$stmt = $pdo->prepare('SELECT * FROM users WHERE email = :email AND active = :active');
$stmt->execute(['email' => $email, 'active' => 1]);
$user = $stmt->fetch();          // одна строка
$all  = $stmt->fetchAll();       // все строки

// Позиционные плейсхолдеры (?)
$stmt = $pdo->prepare('INSERT INTO logs (msg, level) VALUES (?, ?)');
$stmt->execute([$msg, $level]);
$id = $pdo->lastInsertId();

Важно: плейсхолдеры подставляют только значения, но не имена таблиц/колонок — их (если нужны динамически) валидируют по белому списку.

Транзакции через PDO:

$pdo->beginTransaction();
try {
    $pdo->prepare('UPDATE accounts SET balance = balance - ? WHERE id = ?')->execute([100, 1]);
    $pdo->prepare('UPDATE accounts SET balance = balance + ? WHERE id = ?')->execute([100, 2]);
    $pdo->commit();
} catch (\Throwable $e) {
    $pdo->rollBack();
    throw $e;
}

Режимы выборки (fetch): FETCH_ASSOC (ассоц. массив), FETCH_OBJ (stdClass), FETCH_CLASS (в объекты класса), FETCH_COLUMN (одна колонка). Для больших выборок — итерировать while ($row = $stmt->fetch()) (не грузить всё в память). На практике поверх PDO обычно работает ORM (Eloquent/Doctrine), но понимать PDO нужно.


Регулярные выражения

В PHP регулярки — расширение PCRE (Perl-совместимые). Паттерн — строка в разделителях (обычно /.../), после закрывающего разделителя — флаги. Здесь — как ими пользоваться (не про построение самих паттернов).

Основные функции:

// preg_match — есть ли совпадение (1/0), $m — найденные группы
if (preg_match('/(\d{4})-(\d{2})-(\d{2})/', '2024-05-01', $m)) {
    [$full, $year, $month, $day] = $m;   // $m[0] — всё совпадение, дальше группы
}

// preg_match_all — все совпадения
preg_match_all('/\d+/', 'a1 b22 c333', $m);   // $m[0] = ['1','22','333']

// preg_replace — замена ($1 — обратная ссылка на группу)
echo preg_replace('/(\d{4})-(\d{2})-(\d{2})/', '$3.$2.$1', '2024-05-01'); // 01.05.2024

// preg_replace_callback — замена через функцию
echo preg_replace_callback('/\d+/', fn($m) => $m[0] * 2, 'a1 b2'); // a2 b4

// preg_split — разбить строку по паттерну
$parts = preg_split('/[\s,]+/', 'a, b,  c'); // ['a','b','c']

// preg_quote — экранировать спецсимволы в пользовательском вводе перед вставкой в паттерн
$pattern = '/' . preg_quote($userInput, '/') . '/';

Флаги (модификаторы) после закрывающего разделителя:

  • i — регистронезависимый поиск.
  • m — многострочный (^/$ работают на каждой строке).
  • s — . совпадает и с переносом строки.
  • u — режим UTF-8 (обязателен для корректной работы с кириллицей/юникодом).
  • x — расширенный (пробелы в паттерне игнорируются, можно комментарии).
preg_match('/привет/ui', 'ПРИВЕТ, мир');   // сработает: i + u для юникода

Именованные группы и доступ к ним:

preg_match('/(?<year>\d{4})-(?<month>\d{2})/', '2024-05', $m);
echo $m['year'];   // 2024

Практика: preg_match — проверить/извлечь; preg_replace/preg_replace_callback — заменить; preg_split — разбить; preg_quote — безопасно вставить пользовательский текст в паттерн. Возврат false у preg_* означает ошибку (например, битый паттерн) — отличать от «нет совпадений» (0).


Модель выполнения: SAPI, PHP-FPM, жизненный цикл

Важная тема на Senior: как именно PHP исполняет код и почему он «забывает» всё между запросами.

Как PHP исполняет код (движок Zend)

  1. Лексинг/парсинг — исходник разбирается в токены и AST (дерево).
  2. Компиляция — AST компилируется в опкоды (opcodes) — промежуточный байткод.
  3. Выполнение — виртуальная машина Zend (Zend VM) исполняет опкоды.

По умолчанию это происходит на каждый запрос заново. OPcache кэширует скомпилированные опкоды в разделяемой памяти, убирая шаги 1–2 на повторных запросах (обязателен на проде). JIT (PHP 8) может компилировать «горячие» опкоды в машинный код — выигрыш в основном на CPU-bound.

SAPI

SAPI (Server API) — способ, которым PHP интегрируется с окружением/веб-сервером. Разные SAPI:

  • php-fpm — FastCGI Process Manager (стандарт для веба с Nginx/Apache).
  • mod_php — модуль внутри Apache (устаревающий подход).
  • cli — командная строка (скрипты, воркеры очередей, крон).
  • cgi, встроенный сервер (php -S) и др.

Один и тот же код работает под разными SAPI; от SAPI зависит окружение (например, суперглобали $_GET/$_POST есть в веб-SAPI, а в CLI — аргументы $argv).

PHP-FPM и жизненный цикл запроса

PHP-FPM держит пул воркер-процессов. Схема запроса:

Браузер → Nginx (отдаёт статику сам, PHP проксирует по FastCGI)
        → PHP-FPM (свободный воркер из пула)
        → воркер исполняет PHP-скрипт (RINIT → выполнение → RSHUTDOWN)
        → ответ → Nginx → браузер
        → воркер очищает память запроса и ждёт следующий запрос

Фазы жизненного цикла модуля/процесса: MINIT (старт процесса — инициализация расширений), RINIT (начало запроса), выполнение скрипта, RSHUTDOWN (конец запроса — очистка), MSHUTDOWN (остановка процесса).

Настройки пула FPM (pm): static (фиксированное число воркеров), dynamic (в диапазоне min/max), ondemand (по требованию); pm.max_children ограничивает параллелизм; pm.max_requests — воркер перезапускается после N запросов (борьба с утечками памяти в расширениях).

Модель shared-nothing (ключевая идея)

Каждый запрос обрабатывается изолированно: воркер выделяет память под запрос, выполняет скрипт, а в конце вся память запроса освобождается — состояние между запросами по умолчанию не сохраняется («shared-nothing»).

Следствия:

  • Данные между запросами хранят во внешних хранилищах: сессии (файлы/Redis), БД, кэш (Redis/Memcached) — не в памяти процесса.
  • Это упрощает горизонтальное масштабирование (запросы независимы, можно раскидывать по воркерам/серверам) и делает утечку памяти в рамках одного запроса не такой фатальной (память всё равно освободится в конце).
  • Исключение — резидентные раннеры (Swoole, RoadRunner, FrankenPHP): там приложение живёт между запросами в памяти (большой прирост скорости), но нужно аккуратно следить за состоянием/утечками в долгоживущих объектах.

Нововведения по версиям

PHP 7.x

  • Существенный рост производительности относительно 5.x (движок Zend).
  • Скалярные type hints и типы возвращаемых значений.
  • Анонимные классы.
  • Null coalescing ??, spaceship <=>.
  • 7.1: nullable-типы ?T, множественный catch. 7.4: типизированные свойства, arrow functions, preload, ??=.

PHP 8.x

  • JIT (8.0).
  • Union types int|float (8.0).
  • Named arguments — передача по имени (8.0).
  • Attributes — нативные аннотации-метаданные #[Route('/user')] (8.0).
  • Match expression — строгое сравнение, возвращает значение, без «проваливания» (8.0).
  • Constructor Property Promotion (8.0), nullsafe ?-> (8.0).
  • Enums, readonly-свойства, Fibers, first-class callable, final-константы классов/интерфейсов (8.1).
  • readonly-классы (8.2).
  • Типизированные константы классов, #[\Override] (8.3).
  • Асимметричная видимость private(set), property hooks (8.4).
// Match
$result = match ($input) {
    'value1' => 'Result 1',
    'value2', 'value3' => 'Result 2',
    default => 'Default',
};

Pipe-оператор |> (PHP 8.5) — последовательное применение функций к значению (стрелочную функцию справа нужно брать в скобки):

$output = $input
    |> trim(...)
    |> (fn (string $s) => str_replace(' ', '-', $s))
    |> strtolower(...);

Вероятные вопросы

Чем == отличается от ===? == сравнивает с приведением типов, === — по типу и значению. В PHP 8 сравнение строки с числом стало безопаснее.

Передаются ли объекты по ссылке? Нет, по значению дескриптора: копируется «ручка» на тот же объект, поэтому изменения объекта видны снаружи. Полную независимую копию даёт clone (глубокую — через __clone).

Что такое copy-on-write? Массив не копируется физически, пока его не изменяют; при первой записи создаётся отдельная копия. Экономит память.

self vs static? self — класс, где написан код (фиксируется на компиляции); static — реальный класс времени выполнения (позднее статическое связывание).

Интерфейс или абстрактный класс — когда что? Интерфейс — чистый контракт «что умеет», их можно реализовать несколько. Абстрактный класс — общая частичная реализация для семейства классов, наследуется только один.

Как работает сборка мусора? Основа — счётчик ссылок (refcount): объект удаляется сразу, когда счётчик падает до 0. Циклические ссылки (объекты ссылаются друг на друга) счётчик не ловит — их собирает алгоритм mark-and-sweep (обнаружение циклов) по заполнении корневого буфера (~10 000).

Что такое zval и refcount? zval — внутренняя структура значения (тип + значение + служебные поля); refcount — счётчик ссылок на значение. Присваивание увеличивает, unset/выход из области — уменьшает; при 0 значение освобождается.

Как в PHP ловятся циклические ссылки? Кандидаты (refcount уменьшился, но не до 0) попадают в root buffer; при его заполнении запускается сбор циклов (mark-and-sweep / Bacon–Rajan), недостижимые снаружи циклы освобождаются. Управление — gc_enable/disable/collect_cycles.

Зачем WeakReference / WeakMap? Сослаться на объект, не мешая его удалению по счётчику. WeakMap — карта «объект→данные» со слабыми ключами: при уничтожении объекта запись исчезает сама. Для кэша/метаданных без утечек (обычный массив держал бы объект сильной ссылкой).

Бывают ли утечки памяти в PHP? В вебе редко (shared-nothing — память освобождается в конце запроса). Реальны в долгоживущих воркерах (Swoole/RoadRunner/CLI-очереди): растущие статические/глобальные структуры, незакрытые ресурсы. Лечат перезапуском воркера после N задач и ограничением кэшей.

Чем Error отличается от Exception? Оба реализуют Throwable. Error — ошибки движка (обычно баг в коде), Exception — прикладные ситуации, которые обрабатывают. Поймать оба можно по Throwable.

Зачем declare(strict_types=1) и где он действует? Запрещает неявное приведение примитивов в сигнатурах; действует только в файле, где объявлен (на вызовы из него).

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

Как защититься от SQL-инъекций / XSS / CSRF? Prepared statements; экранирование вывода htmlspecialchars + CSP; CSRF-токены и SameSite-cookie.

Разница install и update в Composer? install ставит версии из composer.lock; update пересчитывает версии по ограничениям composer.json и обновляет lock.

Mock vs stub? Stub подменяет данные зависимости (проверка состояния), mock проверяет факт и параметры вызова (проверка поведения).

Поддерживает ли PHP асинхронность? На уровне языка классической модели — нет; есть Fibers, ReactPHP, Swoole, RoadRunner, а тяжёлые задачи выносят в очереди.

Что такое позднее статическое связывание? Механизм, при котором static:: разрешается в класс, реально вызвавший метод, а не в тот, где метод определён.

Что такое variadic-функция и чем лучше func_get_args()? Функция с ...$args, собирающая переменное число аргументов в массив. В отличие от func_get_args() позволяет типизировать элементы и явно видна в сигнатуре.

Чем ... при вызове отличается от ... в сигнатуре? В сигнатуре ... собирает аргументы в массив (variadic), при вызове — распаковывает (spread) массив в отдельные аргументы. Ещё ... объединяет массивы.

Чем DTO отличается от Value Object? DTO — контейнер для переноса данных между слоями, без поведения и без гарантий. VO — иммутабельный объект, самовалидируемый в конструкторе, с равенством по значению; делает невалидные состояния непредставимыми.

Зачем нужен SplObjectStorage? Хранить уникальные объекты и привязывать к ним данные, используя сам объект как ключ (обычный массив объект ключом не поддерживает).

Где реально используется Reflection API? Autowiring в DI-контейнерах (разбор типов аргументов конструктора), чтение атрибутов (роуты, ORM-маппинг, валидация), моки в тестах. В проде результаты кэшируют.

Как правильно хранить пароли? Адаптивный медленный хеш с солью: password_hash (bcrypt/argon2id), проверка password_verify (constant-time), перехеширование по password_needs_rehash. Никогда — md5/sha1/обратимое шифрование.

Чем аутентификация отличается от авторизации? Аутентификация — «кто ты» (проверка личности), авторизация — «что тебе можно» (проверка прав). Это разные этапы.

Что такое IDOR и как защититься? Доступ к чужому объекту по прямой ссылке (id). Защита — проверка принадлежности объекта текущему пользователю на сервере (WHERE user_id = :me), а не только существования id.

Как избежать race condition при конкурентном доступе? Пессимистичные/оптимистичные блокировки БД, атомарные операции (INCR, атомарный UPDATE), распределённые блокировки (Redis/symfony/lock), идемпотентные обработчики.

Дают ли Fibers параллелизм? Нет. Fibers — кооперативная многозадачность (приостановка/возобновление); это фундамент для событийных библиотек. Настоящие потоки — расширение parallel, масштабирование по процессам — PHP-FPM/воркеры.

Чем конкурентность отличается от параллелизма? Конкурентность — чередование задач (переключение при ожидании I/O, в т.ч. на одном ядре); параллелизм — одновременное выполнение на нескольких ядрах. Fibers/Swoole/ReactPHP дают конкурентность; настоящий параллелизм — процессы/потоки.

Как работает yield from? Делегирует генерацию другому генератору/массиву/Traversable — «вставляет» его значения в текущий генератор. Сохраняет ключи, пробрасывает return вложенного генератора; незаменим для рекурсивных генераторов (обход дерева).

Что делает getReturn() у генератора? Возвращает значение, которое генератор вернул через return (доступно после окончания перебора). send() передаёт значение внутрь генератора (корутины).

Можно ли пройти генератор дважды? Нет, генератор однопроходный — rewind после старта бросит ошибку; нужно вызвать функцию-генератор заново.

Зачем генераторы, если есть массивы? Ленивость: значения вычисляются по одному, вся коллекция не держится в памяти — для больших файлов, выборок БД, бесконечных последовательностей.

Где хранятся данные сессии и как масштабировать? По умолчанию в файлах на диске сервера (session.save_handler = files). При нескольких серверах — общее хранилище (Redis/БД) или sticky sessions, иначе запрос уйдёт на сервер без данных.

Чем gc_maxlifetime отличается от cookie_lifetime? gc_maxlifetime — сколько данные сессии живут на сервере (таймаут неактивности); cookie_lifetime — сколько cookie с id живёт в браузере. Независимы: сессия «протухнет», если серверные данные удалены сборщиком.

Как защититься от session fixation? session_regenerate_id(true) после логина/смены привилегий + session.use_strict_mode = 1 (не принимать чужой неинициализированный id).

Зачем session_write_close()? Освободить блокировку сессии раньше конца запроса — чтобы параллельные запросы того же пользователя (несколько AJAX) не ждали. Сессия блокируется на время открытого запроса.

Какие флаги cookie сессии важны для безопасности? httponly (недоступна из JS — против XSS-кражи), secure (только HTTPS), samesite=Lax/Strict (против CSRF).

Что делает HttpOnly? Запрещает доступ к cookie из JavaScript (document.cookie) — защита от кражи cookie через XSS. Не защищает от CSRF (для этого — SameSite/токены).

Что делает Secure? Cookie отправляется только по HTTPS — защита от перехвата в открытой сети.

Что такое SameSite и его значения? Управляет отправкой cookie в межсайтовых запросах (защита от CSRF): Strict (никогда cross-site), Lax (только при навигации-переходе GET, дефолт), None (всегда, но обязательно с Secure).

Expires vs Max-Age? Оба задают срок жизни cookie: Expires — абсолютная дата, Max-Age — секунды (приоритетнее). Без них cookie сессионная (до закрытия браузера).

Зачем префиксы __Host-/__Secure-? Дополнительная защита: __Secure- требует Secure; __Host- — Secure + Path=/ + запрет Domain (привязка к хосту, нельзя подменить с поддомена).

first-party vs third-party cookie? first-party — cookie текущего сайта; third-party — cookie другого домена (реклама/виджеты/SSO). Для cross-site нужен SameSite=None; Secure; браузеры всё сильнее ограничивают third-party.

Почему в cookie не хранят много данных? Размер ~4 КБ, и всё содержимое шлётся на сервер при каждом запросе к домену; для больших данных — сессии на сервере или localStorage/IndexedDB.

Зачем трейты и чем отличаются от интерфейсов/абстрактных классов? Трейт — переиспользование реализации без наследования (можно много, отношение «умеет делать»). Интерфейс — контракт без реализации; абстрактный класс — частичная реализация, наследуется один. Трейт — не тип (нет type-hint).

Как разрешить конфликт методов трейтов? insteadof (выбрать чей метод) и as (алиас / смена видимости).

Зачем PDO и prepared statements? PDO — единый интерфейс к разным СУБД; prepared statements передают данные отдельно от SQL (главная защита от инъекций). Плейсхолдеры — только для значений, не для имён таблиц/колонок.

Как в PDO включить исключения при ошибках? PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION при создании соединения; с PHP 8.0 это режим по умолчанию.

Зачем флаг u в регулярках? Режим UTF-8 — для корректной работы с кириллицей/юникодом. preg_quote экранирует пользовательский ввод перед вставкой в паттерн.

Что такое SAPI? Способ интеграции PHP с окружением: php-fpm (веб), cli (скрипты/воркеры), mod_php, встроенный сервер. От SAPI зависит окружение (суперглобали vs $argv).

Как PHP исполняет код? Парсинг → компиляция в опкоды → выполнение в Zend VM. OPcache кэширует опкоды (убирает парсинг/компиляцию), JIT компилирует горячие участки в машинный код.

Что такое shared-nothing и почему PHP «забывает» состояние? Каждый запрос обрабатывается изолированно, память запроса освобождается в конце — состояние между запросами не хранится. Поэтому данные держат в БД/Redis/сессиях; это упрощает горизонтальное масштабирование. Исключение — резидентные раннеры (Swoole/RoadRunner/FrankenPHP).

Что делает pm.max_requests в PHP-FPM? Перезапускает воркер после N запросов — борьба с накоплением утечек памяти в долгоживущем процессе.