PHP
Материал для подготовки к собеседованию (Middle / Senior). Термины на английском там, где это принято.
Содержание
- Типы данных и переменные
- Подключение файлов: include / require
- ООП
- Трейты
- Исключения и ошибки
- Генераторы и итераторы
- Управление памятью и сборка мусора
- Пространства имён и автозагрузка
- Composer
- Reflection API
- SPL
- Конкурентность, асинхронность и очереди
- Сессии и куки
- Безопасность
- Производительность
- Кэширование
- Тестирование
- Стандарты PSR
- Принципы и паттерны
- PDO и работа с БД
- Регулярные выражения
- Модель выполнения: SAPI, PHP-FPM, жизненный цикл
- Нововведения по версиям
- Вероятные вопросы
Типы данных и переменные
Скалярные типы: 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). Как работает:
- Значения, у которых refcount уменьшился, но не до нуля, попадают в корневой буфер (root buffer) — кандидаты на цикл.
- Когда буфер заполняется (по умолчанию 10 000 возможных корней), запускается сбор: алгоритм помечает достижимое от «настоящих» корней и определяет группы, замкнутые сами на себя (недостижимые снаружи).
- Такие циклы освобождаются.
Ручное управление:
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
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)
- Лексинг/парсинг — исходник разбирается в токены и AST (дерево).
- Компиляция — AST компилируется в опкоды (opcodes) — промежуточный байткод.
- Выполнение — виртуальная машина 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 запросов — борьба с накоплением утечек памяти в долгоживущем процессе.