PHP Core Knowledge Base

Синтаксис строк: Double vs Single Quote

// Single quotes - буквальные строки, никакой интерпретации
'Hello $name'  // Выведет: Hello $name

// Double quotes - интерпретирует переменные и экранирующие символы
"Hello $name"  // Выведет: Hello John (если $name = 'John')
"Line1\nLine2"  // Новая строка работает

// Heredoc - многострочная строка с интерпретацией
$text = <<$name,
This is a multiline string.
EOT;

// Nowdoc - многострочная строка БЕЗ интерпретации (как single quotes)
$text = <<<'EOT'
Hello $name,
This is literal.
EOT;

Строковая интерполяция (String Interpolation)

$name = "Alice";
$data = ['age' => 30];

// Простая переменная
"Hello $name"

// Через фигурные скобки для сложных выражений
"Age: {$data['age']}"  // Правильно
"Age: $data['age']"    // ОШИБКА - неправильная интерпретация

// Использование {} для явности
"{$name}'s age is {$data['age']}"

Heredoc и Nowdoc — многострочные строки

// Синтаксис: <<<ИДЕНТИФИКАТОР (без пробелов после <<<)
$name = "Анна";
$text = <<<EOT
Привет, $name!
Это многострочный текст.
Поддерживает переносы и "кавычки" без экранирования.
EOT;

echo $text;
// Вывод:
// Привет, Анна!
// Это многострочный текст.
// Поддерживает переносы и "кавычки" без экранирования.

// Синтаксис: <<<'ИДЕНТИФИКАТОР' (в одинарных кавычках)
$name = "Анна";
$text = <<<'EOT'
Привет, $name!
Здесь $name не заменится на "Анна".
\n и \t останутся как текст.
EOT;

echo $text;
// Вывод:
// Привет, $name!
// Здесь $name не заменится на "Анна".
// \n и \t останутся как текст.

// Идентификатор: любой (EOT, HTML, SQL, JSON), любые буквы/цифры/подчёркивания,
//   не должен начинаться с цифры. Принято — UPPERCASE.

// Heredoc: без кавычек вокруг идентификатора
$x = <<<HTML
<div>$content</div>
HTML;

// Nowdoc: с одинарными кавычками
$x = <<<'HTML'
<div>$content</div>
HTML;

// Распространённая ошибка — пробелы и переменная после <<<
$x = << $name     // SYNTAX ERROR — нужен идентификатор без пробела
text
EOT;

// PHP 7.3+ — закрывающий идентификатор может иметь отступ
// (отступ автоматически удалится из всех строк):
$x = <<<EOT
    Первая строка
    Вторая строка
    EOT;
// Содержимое будет "Первая строка\nВторая строка" — без ведущих пробелов

+--------------------------------+--------------+--------------+
| Особенность                    | Heredoc      | Nowdoc       |
+--------------------------------+--------------+--------------+
| Синтаксис открытия             | <<<EOT       | <<<'EOT'     |
| Интерпретация переменных       | да           | нет          |
| Escape-последовательности      | да (\n, \t)  | нет          |
| Аналог в обычных строках       | " "          | ' '          |
| Когда использовать             | шаблоны с    | литеральный  |
|                                | подстановкой | код, SQL,    |
|                                |              | regex        |
+--------------------------------+--------------+--------------+

// 1. Heredoc для шаблонов с переменными — HTML, SQL с параметрами, письма
$body = <<<HTML
<h1>Привет, $userName!</h1>
<p>Ваш заказ #$orderId на сумму $total руб.</p>
HTML;

// 2. Nowdoc для литерального текста — примеры кода, regex, тексты с $
$exampleCode = <<<'PHP'
<?php
$user = User::find(1);
echo "Hello, $user->name!";
PHP;
// Все $ останутся как есть, для документации/туториалов — идеально

// 3. SQL — обычно Heredoc с параметрами или Nowdoc для статичного запроса
$query = <<<'SQL'
SELECT u.id, u.email
FROM users u
WHERE u.status = 'active'
  AND u.created_at > '2024-01-01'
SQL;
// Не нужно экранировать одинарные кавычки строки SQL!

// 4. JSON-шаблон
$json = <<<'JSON'
{
  "name": "value",
  "nested": {"key": 123}
}
JSON;

// 1. Закрывающий идентификатор в начале строки (до PHP 7.3)
//    Любые пробелы или табы перед ним — Parse error
//    С 7.3+ — отступ разрешён, но автоматически удаляется
$x = <<<EOT
text
    EOT;   // 7.2: SYNTAX ERROR; 7.3+: OK

// 2. После закрывающего идентификатора — только ; или ничего
$x = <<<EOT
text
EOT . "more";  // SYNTAX ERROR в PHP < 7.3

$x = <<<EOT
text
EOT;
$x .= "more";       // — конкатенация после

// 3. Идентификатор содержится в тексте — закроется раньше времени
$x = <<<EOT
Сообщение содержит слово EOT внутри текста
EOT;
// Текст оборвётся на первом EOT в начале строки.
// Решение: использовать уникальный идентификатор, не встречающийся в тексте.

// 4. Heredoc внутри функции/массива до PHP 7.3 требовал ; в конце
$arr = [<<<EOT
text
EOT
];  // 7.2: SYNTAX ERROR; 7.3+: OK (трейлинг ; можно опустить)

// 5. $ в Nowdoc — не нужно экранировать (в отличие от Heredoc)
$h = <<<EOT
Цена: \$100   // нужно экранировать $, иначе PHP попытается найти $100
EOT;
$n = <<<'EOT'
Цена: $100     // в Nowdoc — экранировать не нужно
EOT;

PHP 8+ Функции строк

// Проверить содержит ли строка подстроку
str_contains("Hello World", "World");  // true

// Проверить начало строки
str_starts_with("https://example.com", "https");  // true

// Проверить конец строки
str_ends_with("file.pdf", ".pdf");  // true

// Практический пример - валидация URL в Laravel контроллере
if (!str_starts_with($url, "https://")) {
    return response()->json(['error' => 'Invalid URL']);
}

Многобайтовые строки (mb_string)

$text = "Привет мир";

// Обычные функции работают с БАЙТАМИ, не с символами!
strlen("Привет");      // 12 (3 байта на каждый кириллический символ)

// mb функции работают с СИМВОЛАМИ
mb_strlen("Привет");     // 6 (6 символов, UTF-8)
mb_substr($text, 0, 3);   // "При" (3 символа, не байта)
mb_strtoupper($text);     // "ПРИВЕТ МИР"
mb_strtolower($text);     // "привет мир"
mb_convert_case($text, MB_CASE_TITLE);  // Первая буква заглавная

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

// preg_match - найти первое совпадение
if (preg_match('/^\d{3}-\d{3}-\d{4}$/', $phone)) {
    // Телефон в формате XXX-XXX-XXXX
}

// preg_match с захватывающими группами
preg_match('/(\w+)@(\w+\.\w+)/', "test@example.com", $matches);
// $matches[0] = "test@example.com" (полное совпадение)
// $matches[1] = "test" (первая группа)
// $matches[2] = "example.com" (вторая группа)

// preg_match_all - найти ВСЕ совпадения
preg_match_all('/\d+/', "1 2 3 4 5", $numbers);
// $numbers[0] = ["1", "2", "3", "4", "5"]

// preg_replace - замена по паттерну
$clean = preg_replace('/[^a-zA-Z0-9]/', '', $input);
// Удаляет все символы кроме букв и цифр

// Практический пример - валидация email в Laravel
if (!preg_match('/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/', $email)) {
    // Некорректный email
}

/                  — начало и конец регулярки (разделитель)
^                  — начало строки: проверка с первого символа
[a-zA-Z0-9._%+-]+  — локальная часть (то, что ДО @):
                     любые буквы, цифры, точки, подчёркивания, плюс, процент, дефис
                     + означает «один или более раз»
                     примеры: ivan, i.van, ivan+spam, ivan_123
@                  — символ @ (ровно один)
[a-zA-Z0-9.-]+     — имя домена (после @ до точки): gmail, yandex, my-site
\.                 — ЭКРАНИРОВАННАЯ точка — буквальный символ "."
[a-zA-Z]{2,}       — доменная зона: только буквы, минимум 2 (com, ru, org)
$                  — конец строки: после доменной зоны ничего быть не должно
/                  — закрытие регулярки

$email = "john.doe@example.com";

// Пошаговое сопоставление:
// ^                     → начинаем с первого символа: j
// [a-zA-Z0-9._%+-]+     → берёт "john.doe" (точка внутри локальной части разрешена)
// @                     → находит символ @
// [a-zA-Z0-9.-]+        → берёт "example"
// \.                    → находит буквальную точку
// [a-zA-Z]{2,}          → берёт "com" (3 буквы, минимум 2)
// $                     → строка закончилась → match
// → preg_match вернёт 1 (true)

// preg_match() возвращает:
//   1     — строка соответствует шаблону
//   0     — НЕ соответствует
//   false — ошибка в самом шаблоне

// ! инвертирует результат:
if (!preg_match('/.../', $email)) {
    // сюда попадаем, когда email НЕ соответствует формату
    // → можно бросить ValidationException
}

// ivan@example       — нет точки и доменной зоны (\. не найден)
// ivan@.com          — домен пустой (между @ и точкой ничего нет)
// ivan@example.c     — доменная зона "c" короче 2 символов
// ivan@example.com.  — лишняя точка в конце (нарушает $)
// ivan#example.com   — нет символа @

preg_match_all('/\d+/', "1 2 3 4 5", $numbers);

// Разбор паттерна:
// \d  — один любой цифровой символ (0-9)
// +   — один или более раз подряд
// \d+ — последовательность из одной или нескольких цифр

// Функция идёт по строке слева направо и берёт куски, подходящие под \d+:
//   "1" — пробел — стоп → совпадение
//   "2" — пробел — стоп → совпадение
//   "3", "4", "5" — то же

// Результат в $numbers (двумерный массив):
$numbers[0] === ["1", "2", "3", "4", "5"];

// Функция возвращает количество совпадений (целое число):
$count = preg_match_all('/\d+/', "1 2 3 4 5", $numbers);
echo $count;  // 5

preg_match_all('/\d+/', "abc 123 def 45 6", $numbers);
// $numbers[0] = ["123", "45", "6"]
// Пробелы и буквы проигнорированы; "123" — три цифры подряд считаются одним совпадением.

preg_match_all('/(\w+)@(\w+\.\w+)/', "a@x.com b@y.org", $m);
// $m[0] = ["a@x.com", "b@y.org"]     — полные совпадения
// $m[1] = ["a", "b"]                  — первая группа (то, что в первых скобках)
// $m[2] = ["x.com", "y.org"]          — вторая группа

sprintf и форматирование строк

// sprintf возвращает отформатированную строку
$formatted = sprintf("Hello %s, you are %d years old", "Alice", 30);
// "Hello Alice, you are 30 years old"

// printf выводит прямо
printf("Price: $%.2f", 19.5);  // "Price: $19.50"

// Форматы:
// %s - string
// %d - integer
// %f - float (по умолчанию 6 знаков после запятой)
// %.2f - float с 2 знаками после запятой
// %x - hex
// %b - binary

// Практический пример - форматирование цены
$price = sprintf("$%.2f", 99.5);  // "$99.50"

Что такое массив. Индексированный vs ассоциативный

$list = ["яблоко", "банан", "апельсин"];

// PHP под капотом сгенерировал ключи 0, 1, 2:
// [ 0 => "яблоко", 1 => "банан", 2 => "апельсин" ]

echo $list[0];  // "яблоко"
echo $list[1];  // "банан"

// Использование: списки, упорядоченные коллекции, где
// позиция элемента имеет значение (история, очередь, лог).

$person = [
    "name" => "Иван",
    "age"  => 30,
    "city" => "Москва",
];

echo $person["name"];  // "Иван"
// Ключ — это имя, оно несёт смысл. Не позиция.

// Ключи могут быть смешанными:
$mixed = [1 => "один", "key" => "value"];

// Использование: конфиги, DTO, данные из формы/БД/JSON,
// где у каждого поля есть осмысленное имя.

// PHP внутри хранит массив как упорядоченную hash-таблицу.
// Поэтому ИНДЕКСИРОВАННЫЙ массив — это всего лишь
// ассоциативный с автогенерированными числовыми ключами.

$a = ["x", "y", "z"];
// Эквивалентно:
$a = [0 => "x", 1 => "y", 2 => "z"];

// Поэтому функции типа array_keys, array_values, foreach
// работают одинаково для обоих видов:
array_keys($a);       // [0, 1, 2]
array_keys($person);  // ["name", "age", "city"]

// Проверить, "индексированный" массив (PHP 8.1+):
array_is_list($a);      // true (ключи 0..n-1 по порядку)
array_is_list($person); // false

Оператор => — все 6 контекстов использования

$arr = [
    'name' => 'Иван',
    'age'  => 30,
    5      => 'пятый',   // ключ может быть числом
];

// ─── Создание массива (литерал) — внутри [...] нужен => ───
$arr = ['name' => 'Иван', 'age' => 30];

// ─── Добавление элемента в существующий массив — снаружи [...] нужен = ───
$arr['email'] = 'ivan@x.kz';       // ключ в [], значение через =
$arr[5] = 'пять';                 // верно

// ─── Синтаксические ошибки ───
$arr['name' => 'Иван'];        // SYNTAX ERROR: внутри [] только ключ
$arr['name'] => 'Иван';        // SYNTAX ERROR: => не оператор присваивания

foreach ($arr as $key => $value) {
    echo "$key => $value";
}
// Без => получили бы только значения:
// foreach ($arr as $value) { ... }

// fn($x) => выражение  — короткая запись анонимной функции.
// => здесь заменяет return и фигурные скобки.

// Длинная форма:
$squared = array_map(function($n) {
    return $n * $n;
}, $numbers);

// Стрелочная (короткая):
$squared = array_map(fn($n) => $n * $n, $numbers);

// Особенности стрелочных функций:
// — тело только ОДНО выражение (не несколько строк, не {})
// — автоматически захватывают внешние переменные (без use)
$multiplier = 3;
$tripled = array_map(fn($n) => $n * $multiplier, $numbers);
// $multiplier "пойман" автоматически — в обычной function требовался бы use ($multiplier)

// => разделяет проверяемое значение и возвращаемый результат
$result = match($status) {
    200           => 'OK',
    404           => 'Not Found',
    500, 502, 503 => 'Server Error',
    default       => 'Unknown',
};

// В отличие от switch:
//   — строгое сравнение (===), не нестрогое
//   — возвращает значение (можно присвоить в переменную)
//   — обязателен default или match попадание (иначе UnhandledMatchError)

function gen(): Generator {
    yield 'a' => 1;
    yield 'b' => 2;
    yield 'c' => 3;
}

foreach (gen() as $k => $v) {
    echo "$k: $v\n";
}
// Без => в yield генератор выдаёт автоматические числовые ключи 0, 1, 2...

// Распаковка ассоциативного массива в переменные с указанием ключей
$user = ['name' => 'Анна', 'age' => 25, 'role' => 'admin'];

['name' => $name, 'age' => $age] = $user;
// $name = 'Анна', $age = 25 (role игнорируется)

// До PHP 7.1 — только позиционная (без ключей):
// [$first, $second, $third] = $array;

// Это два шага:
// 1. Сначала [] с => создаёт ассоциативный массив:
//    ["a" => 1, "b" => 2]
// 2. (object) приводит массив к объекту — получается stdClass,
//    где ключи становятся публичными свойствами:

$obj = (object)["a" => 1, "b" => 2];

// Эквивалентно:
$obj = new stdClass();
$obj->a = 1;
$obj->b = 2;

// Доступ:
echo $obj->a;  // 1
// (через -> потому что это объект, не массив)

// Ключи с пробелами или цифровые становятся "магическими":
$obj = (object)["first name" => "Alice", 0 => "zero"];
echo $obj->{"first name"};  // "Alice" — через {} для невалидных имён
// $obj->0 — SYNTAX ERROR, тоже только через $obj->{0}

// Не оператор сравнения — для этого == или ===
$a => $b   // SYNTAX ERROR

// Не стрелочный метод классов (в PHP такого синтаксиса нет)
class User {
    public name => "default";   // SYNTAX ERROR
}

// Не используется в enum для задания значения — там просто =
enum Status: string {
    case DRAFT = 'черновик';     // = (одно равно), не =>
    case DRAFT => 'черновик';    // SYNTAX ERROR
}

array_map - Преобразование элементов

// Применить функцию к каждому элементу
$numbers = [1, 2, 3, 4];
$squared = array_map(fn($n) => $n * $n, $numbers);
// [1, 4, 9, 16]

// Преобразование пользователей в массив ID
$users = [
    ['id' => 1, 'name' => 'Alice'],
    ['id' => 2, 'name' => 'Bob']
];
$ids = array_map(fn($u) => $u['id'], $users);
// [1, 2]

// С объектами
$users = User::all();  // Laravel Collection
$names = array_map(fn($user) => $user->name, $users->toArray());

// Применить функцию к нескольким массивам одновременно
$a = [1, 2, 3];
$b = [10, 20, 30];
$result = array_map(fn($x, $y) => $x + $y, $a, $b);
// [11, 22, 33]
// При разной длине массивов — берётся длина САМОГО ДЛИННОГО,
// недостающие элементы дополняются null (часто источник багов).

// 1. Один массив + ассоциативный → КЛЮЧИ СОХРАНЯЮТСЯ
$users = ['a' => 100, 'b' => 200];
$doubled = array_map(fn($n) => $n * 2, $users);
// ['a' => 200, 'b' => 400] — ключи a, b сохранились

// 2. Несколько массивов → КЛЮЧИ СБРАСЫВАЮТСЯ на 0, 1, 2...
$result = array_map(fn($x, $y) => $x + $y, ['a' => 1], ['b' => 2]);
// [0 => 3] — оба ключа потеряны!

// 3. callback = null + один массив → ПРОСТО КОПИРУЕТ значения
$copy = array_map(null, [1, 2, 3]);
// [1, 2, 3]

// 4. callback = null + несколько массивов → ZIP (склейка попарно)
$zipped = array_map(null, [1, 2, 3], ['a', 'b', 'c']);
// [[1,'a'], [2,'b'], [3,'c']] — как Python zip()

// array_map "под капотом":
$result = [];
foreach ($numbers as $key => $value) {
    $result[$key] = $callback($value);
}

// Когда foreach лучше:
//   — нужны побочные эффекты (логирование, запись в БД)
//   — внутри тела > 1 строки кода
//   — нужно прервать цикл (break/continue) — у array_map нельзя

// Вариант 1: array_map + array_sum (2 прохода по массиву)
$total = array_sum(array_map(
    fn(Item $i) => $i->price(),
    $this->items
));

// Вариант 2: array_reduce (1 проход)
$total = array_reduce(
    $this->items,
    fn(float $carry, Item $i) => $carry + $i->price(),
    0.0
);

// На малых данных (≤ 1000) разницы нет — выбирай по читаемости.
// На больших — reduce 2× быстрее (1 проход + нет промежуточного массива).

array_filter - Фильтрация элементов

// Фильтровать массив по условию
$numbers = [1, 2, 3, 4, 5];
$evens = array_filter($numbers, fn($n) => $n % 2 == 0);
// [2, 4] (ключи сохранены!)

// Удалить null и пустые значения
$data = ['name' => 'Alice', 'age' => null, 'city' => 'NYC'];
$filtered = array_filter($data);
// ['name' => 'Alice', 'city' => 'NYC']

// Фильтровать только ключи
$data = ['user_id' => 1, 'admin_id' => 2, 'name' => 'Test'];
$ids = array_filter($data, fn($k) => str_ends_with($k, '_id'), ARRAY_FILTER_USE_KEY);
// ['user_id' => 1, 'admin_id' => 2]

// Практический пример - получить активных пользователей из БД
$users = User::all();
$active = array_filter(
    $users->toArray(),
    fn($user) => $user['is_active'] === true
);

$data = ['user_id' => 1, 'admin_id' => 2, 'name' => 'Test'];

// 1. По умолчанию — в callback передаётся только ЗНАЧЕНИЕ
array_filter($data, fn($value) => is_numeric($value));
// ['user_id' => 1, 'admin_id' => 2]  — оставляет только числовые значения

// 2. ARRAY_FILTER_USE_KEY — в callback передаётся только КЛЮЧ
array_filter($data, fn($k) => str_ends_with($k, '_id'), ARRAY_FILTER_USE_KEY);
// ['user_id' => 1, 'admin_id' => 2]  — оставляет ключи, заканчивающиеся на _id

// 3. ARRAY_FILTER_USE_BOTH — в callback передаются ОБА: value, key (именно в таком порядке!)
array_filter($data, fn($v, $k) => str_starts_with($k, 'user') && is_numeric($v), ARRAY_FILTER_USE_BOTH);
// ['user_id' => 1]  — ключ начинается с "user" И значение числовое

// В строке $users->toArray() метод toArray() — это НЕ глобальная функция (хелпер).
// Это метод экземпляра класса Illuminate\Support\Collection (или Eloquent\Model).

$users = User::all();     // возвращает Collection (объект)
$users->toArray();          // рекурсивно превращает коллекцию в обычный массив PHP

// Зачем .toArray()? array_filter — встроенная функция PHP, она принимает массив,
// а не Laravel-коллекцию. Поэтому коллекцию приводят к массиву.

// Но если вы остаётесь в мире Laravel — у Collection есть СВОИ методы filter() и where(),
// которые умнее и идиоматичнее:

// Менее идиоматично — выйти из Collection, использовать PHP-функцию:
$active = array_filter($users->toArray(), fn($u) => $u['is_active']);

// Лучше — остаться в Collection:
$active = $users->filter(fn($u) => $u->is_active);

// Ещё лучше — where() для простых проверок:
$active = $users->where('is_active', true);

// Если в итоге нужен массив — в конце .toArray():
$activeArray = $users->where('is_active', true)->toArray();

array_reduce - Свёртка массива

// Свернуть массив в одно значение (сумма)
$numbers = [1, 2, 3, 4];
$sum = array_reduce($numbers, fn($carry, $item) => $carry + $item, 0);
// 10

// Построить ассоциативный массив из списка
$users = [
    ['id' => 1, 'name' => 'Alice'],
    ['id' => 2, 'name' => 'Bob']
];
$indexed = array_reduce($users, function($carry, $user) {
    $carry[$user['id']] = $user['name'];
    return $carry;
}, []);
// [1 => 'Alice', 2 => 'Bob']

// Вычислить статистику
$orders = [
    ['id' => 1, 'amount' => 100],
    ['id' => 2, 'amount' => 200],
    ['id' => 3, 'amount' => 150]
];
$stats = array_reduce($orders, function($carry, $order) {
    $carry['total'] += $order['amount'];
    $carry['count']++;
    $carry['avg'] = $carry['total'] / $carry['count'];
    return $carry;
}, ['total' => 0, 'count' => 0, 'avg' => 0]);

+------+---------+-------------+------------------------------------------+
| Шаг  | $order  | До $carry   | После $carry                              |
+------+---------+-------------+------------------------------------------+
| init | —       | —           | total=0, count=0, avg=0                  |
| 1    | 100     | t=0, c=0    | t=0+100=100, c=1, avg=100/1=100          |
| 2    | 200     | t=100, c=1  | t=100+200=300, c=2, avg=300/2=150        |
| 3    | 150     | t=300, c=2  | t=300+150=450, c=3, avg=450/3=150        |
+------+---------+-------------+------------------------------------------+

Результат $stats:
[
    'total' => 450,
    'count' => 3,
    'avg'   => 150,
]

$total = 0;
$count = 0;
foreach ($orders as $order) {
    $total += $order['amount'];
    $count++;
}
$avg = $count > 0 ? $total / $count : 0;  // защита от деления на ноль
$stats = ['total' => $total, 'count' => $count, 'avg' => $avg];

// Результат идентичен. Разница только в стиле:
// array_reduce — функциональный, всё внутри одного выражения
// foreach — императивный, легче дебажить

+------+--------------+-------------------------+-------------+
| Шаг  | $item       | Вычисление $carry+$item | Новый $carry|
+------+--------------+-------------------------+-------------+
| init | —            | — (начальное = 0)       | 0           |
| 1    | 1            | 0 + 1 = 1               | 1           |
| 2    | 2            | 1 + 2 = 3               | 3           |
| 3    | 3            | 3 + 3 = 6               | 6           |
| 4    | 4            | 6 + 4 = 10              | 10          |
+------+--------------+-------------------------+-------------+

После последнего элемента array_reduce возвращает $carry → 10.

function my_array_reduce(array $array, callable $callback, $initial = null) {
    $accumulator = $initial;

    foreach ($array as $item) {
        // Жёстко зашитый порядок: 1-й arg = аккумулятор, 2-й = элемент
        $accumulator = $callback($accumulator, $item);
    }

    return $accumulator;
}

$sum = 0;
foreach ($numbers as $item) {
    $sum += $item;
}
// результат тот же: 10
// array_reduce — более декларативный способ, особенно для построения структур

// Для типовых операций PHP предоставляет специализированные функции —
// они короче, читаемее и БЫСТРЕЕ array_reduce (реализованы на C).

// Избыточно — переизобретаешь array_sum:
$sum = array_reduce($numbers, fn($c, $i) => $c + $i, 0);

// Идиоматично:
$sum = array_sum($numbers);

// Полный список:
array_sum($arr);              // сумма
array_product($arr);          // произведение
count($arr);                  // количество элементов
max($arr);                    // максимум
min($arr);                    // минимум
array_unique($arr);           // убрать дубли
implode(',', $arr);            // склеить в строку

// Среднее (avg) встроенной нет, но просто:
$avg = array_sum($arr) / count($arr);  // защити count > 0!

array_walk - Изменение элементов с побочными эффектами

// array_walk изменяет массив IN-PLACE (по ссылке!)
$data = [1, 2, 3];
array_walk($data, function(&$item) {
    $item *= 2;
});
// $data = [2, 4, 6]

// С дополнительным параметром (userdata)
$prices = [10, 20, 30];
$tax = 0.1;
array_walk($prices, function(&$price, $key, $taxRate) {
    $price = $price * (1 + $taxRate);
}, $tax);
// $prices = [11, 22, 33]

// ВАЖНО: & влияет ТОЛЬКО на тот параметр, перед которым стоит.
// В этом примере:
//   &$price  — изменение мутирует значение в исходном массиве
//   $key     — копия ключа; изменить его внутри функции невозможно
//   $taxRate — копия userdata; присвоение внутри не повлияет на $tax снаружи

// Что меняется в исходном $prices:
//   значения элементов (11, 22, 33)
//   ключи остаются прежними (0, 1, 2) — их вообще нельзя поменять через array_walk
//   структура массива (количество элементов, порядок) не меняется

// Сигнатура callback для array_walk:
//   function(&$value, $key, $userdata)
//   позиция 1: значение (можно с & для мутации)
//   позиция 2: ключ (всегда копия)
//   позиция 3+: $userdata из 3-го аргумента array_walk (опционально)

// Если поставить & перед $key — будет WARNING, потому что array_walk
// передаёт ключ всегда по значению:
array_walk($arr, function($value, &$key) {
    $key = "new_key";   // бесполезно, ключи не меняются
});
// Чтобы изменить ключи — используйте array_combine + array_map или явный foreach.

// Отправить письма всем пользователям
$users = [
    ['name' => 'Alice', 'email' => 'alice@ex.com'],
    ['name' => 'Bob', 'email' => 'bob@ex.com']
];
array_walk($users, function($user) {
    Mail::to($user['email'])->send(new WelcomeMail($user['name']));
});

// Без & — копия, оригинал не меняется
$data = [1, 2, 3];
array_walk($data, function($item) {
    $item *= 10;            // меняем КОПИЮ — бесполезно
});
print_r($data);              // [1, 2, 3] — без изменений

// С & — ссылка, оригинал изменяется
$data = [1, 2, 3];
array_walk($data, function(&$item) {
    $item *= 10;            // меняем САМ элемент массива
});
print_r($data);              // [10, 20, 30] — массив реально изменился

// Без & — без эффекта
function addOneCopy($num) {
    $num++;
}
$x = 5;
addOneCopy($x);
echo $x;    // 5 — $x не изменился

// С & — функция мутирует переданную переменную
function addOneRef(&$num) {
    $num++;
}
$x = 5;
addOneRef($x);
echo $x;    // 6 — $x изменился, потому что передан по ссылке

// 1. Параметр функции по ссылке (как выше)
function f(&$arg) { ... }

// 2. Возврат по ссылке (редко используется)
function &getRef() { return $this->data; }

// 3. Присваивание по ссылке — создание псевдонима
$a = 10;
$b = &$a;                     // $b — это другое имя для $a
$b = 20;
echo $a;                      // 20 — изменилось через $b

// 4. foreach по ссылке — изменение массива во время перебора
$arr = [1, 2, 3];
foreach ($arr as &$val) {
    $val *= 10;
}
// $arr = [10, 20, 30]

// 5. Битовое И (другой контекст — оператор & между значениями, не префикс)
$flags = 0b1010 & 0b1100;   // 0b1000

$arr = [1, 2, 3];

// Первый foreach по ссылке — изменяем массив
foreach ($arr as &$val) {
    $val *= 10;
}
// После цикла $val ОСТАЁТСЯ ссылкой на последний элемент массива!

// Второй foreach — без &, но переиспользует ту же $val
foreach ($arr as $val) {
    // каждая итерация ПЕРЕЗАПИСЫВАЕТ $arr[2] (последний элемент!)
    // в результате: $arr = [10, 20, &$val=10], затем [10, 20, 20], затем [10, 20, 20]
}
print_r($arr);    // [10, 20, 20] вместо ожидаемого [10, 20, 30]

// Решение: после foreach по ссылке всегда unset:
foreach ($arr as &$val) { $val *= 10; }
unset($val);    // разорвать ссылку

usort и сортировка массивов

// usort - сортирует массив с пользовательским компаратором
$users = [
    ['name' => 'Charlie', 'age' => 25],
    ['name' => 'Alice', 'age' => 30],
    ['name' => 'Bob', 'age' => 28]
];

// Сортировать по возрасту (возрастающе)
usort($users, fn($a, $b) => $a['age'] <=> $b['age']);
// [Charlie, Bob, Alice] (25, 28, 30)

// Сортировать по возрасту (убывающе)
usort($users, fn($a, $b) => $b['age'] <=> $a['age']);

// Сортировать по нескольким параметрам (сначала возраст, потом имя)
usort($users, function($a, $b) {
    $ageCompare = $a['age'] <=> $b['age'];
    if ($ageCompare !== 0) {
        return $ageCompare;
    }
    return $a['name'] <=> $b['name'];
});

// Сортировать объекты (Laravel Model)
$users = User::all();
usort($users->toArray(), fn($a, $b) => $a['created_at'] <=> $b['created_at']);

// -1 — $a меньше $b
// 0  — $a равно $b
// 1  — $a больше $b

var_dump(5 <=> 10);    // int(-1)
var_dump(5 <=> 5);     // int(0)
var_dump(10 <=> 5);    // int(1)

// Работает не только с числами:
var_dump("apple" <=> "banana");  // int(-1) — строки сравниваются лексикографически
var_dump("banana" <=> "apple");  // int(1)

// С массивами — поэлементно (size, потом keys, потом values):
var_dump([1, 2, 3] <=> [1, 2, 3]);  // int(0)
var_dump([1, 2] <=> [1, 2, 3]);     // int(-1) — меньше размер

// С объектами — обычно через __toString() или магию класса

// usort требует от callback вернуть:
//   отрицательное число — если $a должен идти ПЕРЕД $b
//   ноль                — если порядок неважен (равны)
//   положительное       — если $a должен идти ПОСЛЕ $b

// До PHP 7 без <=> писали так:
usort($users, function($a, $b) {
    if ($a['age'] < $b['age']) return -1;
    if ($a['age'] > $b['age']) return 1;
    return 0;
});

// С <=> — одна строка:
usort($users, fn($a, $b) => $a['age'] <=> $b['age']);

// ВАЖНО: НЕ используйте $a - $b как компаратор!
// Работает для int, но ломается для float (теряется точность дробей)
// и для больших чисел (integer overflow). <=> — безопасно всегда.
usort($arr, fn($a, $b) => $a - $b);    // хрупко
usort($arr, fn($a, $b) => $a <=> $b);   // правильно

// По возрастанию (ASC): $a слева, $b справа
usort($users, fn($a, $b) => $a['age'] <=> $b['age']);
// 25, 28, 30

// По убыванию (DESC): поменять местами $a и $b
usort($users, fn($a, $b) => $b['age'] <=> $a['age']);
// 30, 28, 25

// Альтернатива — умножить результат на -1 (читается хуже):
usort($users, fn($a, $b) => -($a['age'] <=> $b['age']));

// Сортировать сначала по возрасту, потом по имени.
// Идея: первое не-нулевое <=> и есть итоговый результат.
// ?: — короткий тернарный (Elvis): если левая часть truthy — её, иначе правую.

usort($users, fn($a, $b) =>
    ($a['age'] <=> $b['age'])
    ?: ($a['name'] <=> $b['name'])
);

// Логика:
// — если возрасты разные (<=> вернёт -1 или 1) — итог это значение
// — если равны (<=> вернёт 0, что falsy) — переходим к сравнению имён

// Для трёх критериев и больше:
usort($users, fn($a, $b) =>
    ($a['department'] <=> $b['department'])
    ?: ($b['salary'] <=> $a['salary'])    // salary DESC (b vs a)
    ?: ($a['name'] <=> $b['name'])
);
// Сначала по отделу (ASC), внутри отдела по зарплате (DESC), внутри по имени (ASC)

array_column, array_combine и другие

// array_column - извлечь столбец из многомерного массива
$users = [
    ['id' => 1, 'name' => 'Alice', 'age' => 30],
    ['id' => 2, 'name' => 'Bob', 'age' => 28]
];
$names = array_column($users, 'name');
// ['Alice', 'Bob']

$indexed = array_column($users, 'name', 'id');
// [1 => 'Alice', 2 => 'Bob']

// array_combine - создать массив с ключами и значениями
$keys = ['a', 'b', 'c'];
$values = [1, 2, 3];
$result = array_combine($keys, $values);
// ['a' => 1, 'b' => 2, 'c' => 3]

// array_merge - объединить массивы
$arr1 = ['a' => 1];
$arr2 = ['b' => 2];
$merged = array_merge($arr1, $arr2);
// ['a' => 1, 'b' => 2]

// array_values и array_keys
$data = ['name' => 'Alice', 'age' => 30];
$values = array_values($data);  // ['Alice', 30]
$keys = array_keys($data);    // ['name', 'age']

Spread Operator и Destructuring

// Spread operator ... для распаковки массива
$arr1 = [1, 2];
$arr2 = [3, 4];
$merged = [...$arr1, ...$arr2];
// [1, 2, 3, 4]

// Распаковка в функцию
function sum($a, $b, $c) {
    return $a + $b + $c;
}
$numbers = [1, 2, 3];
echo sum(...$numbers);  // 6

// Array destructuring (распаковка в переменные)
[$first, $second] = [10, 20];
// $first = 10, $second = 20

// С ассоциативными массивами
['name' => $name, 'age' => $age] = ['name' => 'Alice', 'age' => 30];
// $name = 'Alice', $age = 30

// Пропустить элементы
[$first, , $third] = [1, 2, 3];
// $first = 1, $third = 3 (второй элемент пропущен)

// Практический пример - распаковать функцию в параметры
$userIds = [1, 2, 3];
User::whereIn('id', $userIds)->get();

Класс vs Объект. Создание объекта через new

// КЛАСС — это чертёж (описание): какие свойства и методы будут.
// Сам по себе класс не занимает память для хранения данных.
// Это просто текст программы.

class User {
    public string $name;
    protected int $id;
}

// ОБЪЕКТ — это конкретный дом, построенный по чертежу.
// В памяти выделено место под его свойства, в нём хранятся реальные значения.

$user1 = new User();   // первый объект класса User
$user2 = new User();   // второй объект — независимый

// $user1 и $user2 — РАЗНЫЕ объекты в памяти,
// хотя оба построены по одному и тому же классу User.

$array = (array)new User();   // объект → массив
$array = (array)User;          // ошибка: класс не значение

// Почему так:
// User — это ИМЯ КЛАССА (тип данных), как int или string.
// Его нельзя использовать как переменную или значение.
// Это просто метка для PHP: "вот по такому описанию строить объекты".

// new User() — это ВЫРАЖЕНИЕ, которое возвращает объект.
// А с объектом уже можно делать что угодно: кастить, передавать, сохранять.

// Аналогично с другими операциями над типом:
var_dump(User);            // ошибка
var_dump(new User());      // дамп объекта

// Имя класса как СТРОКА — можно (через ::class или просто "User"):
echo User::class;        // "User" — это уже строка, не класс
echo get_class(new User()); // "User"

class User {
    public string $name;
    public int $age;

    public function __construct(string $name, int $age)
    {
        $this->name = $name;
        $this->age  = $age;
    }
}

// Конструктор вызывается автоматически — поля сразу заполнены
$user = new User("Alice", 30);

echo $user->name;  // "Alice"
// Без конструктора пришлось бы заполнять руками после new:
// $user = new User();
// $user->name = "Alice";
// $user->age  = 30;

$this — ссылка на текущий объект

class User {
    public $name;
    public $email;

    public function __construct($name, $email) {
        $this->name  = $name;     // свойство объекта = аргумент
        $this->email = $email;
    }
}

$user = new User("Alice", "alice@ex.com");
// Внутри __construct $this === $user (тот объект, который создаётся)

class Greeter {
    public $name = "Default";

    public function test($name) {
        echo $name;          // локальная переменная-аргумент
        echo $this->name;    // свойство объекта ("Default")

        $this->name = $name;  // присвоить аргумент в свойство
    }
}

$g = new Greeter();
$g->test("Alice");   // выведет "AliceDefault", потом установит свойство

class Order {
    private array $items = [];

    public function addItem($item): void {
        $this->items[] = $item;
    }

    public function total(): int {
        return array_sum($this->items);
    }

    public function summary(): string {
        // $this->total() — вызов другого метода ЭТОГО ЖЕ объекта
        return "Items: " . count($this->items) . ", total: " . $this->total();
    }
}

class QueryBuilder {
    private array $where = [];
    private ?int $limit = null;

    public function where(string $col, $value): self {
        $this->where[$col] = $value;
        return $this;          // ← возвращаем сам объект
    }

    public function limit(int $n): self {
        $this->limit = $n;
        return $this;
    }
}

// Благодаря return $this — можно цепочкой:
$users = (new QueryBuilder())
    ->where('status', 'active')
    ->where('age', 18)
    ->limit(10);

// Так работают Laravel Query Builder, Eloquent, Collection, и пр.:
// User::where('id', 1)->with('orders')->first() — каждый метод возвращает $this

// 1. В static-методах — нет «текущего объекта», метод принадлежит классу
class Calculator {
    public static function add(int $a, int $b): int {
        return $a + $b;
        // $this здесь — fatal error "Using $this when not in object context"
    }
}
Calculator::add(2, 3);   // вызов без объекта

// 2. В обычных функциях вне класса
function helper() {
    echo $this;        // fatal error
}

// 3. В замыканиях по умолчанию — но можно через Closure::bind
$closure = function() { echo $this->name; };
$closure();   // undefined $this

// Решение — bind замыкания к объекту:
$bound = Closure::bind($closure, $user, User::class);
$bound();    // "Alice"

// До PHP 8.0 — boilerplate с $this в конструкторе:
class User {
    public $name;
    public $email;

    public function __construct($name, $email) {
        $this->name  = $name;     // повторение 3 раза:
        $this->email = $email;   // объявление, аргумент, присвоение
    }
}

// С PHP 8.0+ — promoted properties (объявление + присвоение в одной строке):
class User {
    public function __construct(
        public string $name,
        public string $email,
    ) {}    // тело пустое — PHP сам делает $this->name = $name
}

// Можно совмещать с readonly (PHP 8.1+) — иммутабельные DTO:
final class UserDto {
    public function __construct(
        public readonly string $name,
        public readonly string $email,
    ) {}
}

Когда писать $, а когда нет — все формы доступа к свойствам

class Cart
{
    private array $items = [];           // 1. ОБЪЯВЛЕНИЕ — $ есть (часть синтаксиса)
    public static int $totalCarts = 0;     // 2. static — $ есть и тут

    public function addItem(Item $item): void
    {
        $this->items[] = $item;          // 3. ДОСТУП — items БЕЗ $ (после ->)

        self::$totalCarts++;             // 4. static — $ ОСТАЁТСЯ после ::

        $localCount = count($this->items);  // 5. локальная переменная — $ есть

        // 6. Variable property — магия (редко)
        $field = 'items';
        echo count($this->$field);     // = $this->items, два $ намеренно
    }
}

$this->items     // обращение к свойству items
$this->$items    // variable property — ищет свойство с именем из $items
                  // (если $items = 'name', то это = $this->name)

Static, self, static:: — классовые члены

class Counter {
    public static $count = 0;       // статическое свойство

    public static function increment(): void {
        self::$count++;                     // доступ через self::
    }

    public static function getCount(): int {
        return self::$count;
    }
}

// Вызов через :: без new — объект не создаётся
Counter::increment();
Counter::increment();
echo Counter::getCount();    // 2

// Counter::$count живёт на уровне класса.
// Если бы это было обычное свойство — у каждого объекта свой счётчик.
// Со static — один счётчик на всё приложение.

// Доступ через :: применяется для:

// 1. Статических методов и свойств
ClassName::staticMethod();
ClassName::$staticProperty;

// 2. Констант класса (всегда через ::, даже у объекта)
ClassName::CONSTANT_NAME;
User::STATUS_ACTIVE;

// 3. Псевдо-классов: self::, parent::, static::
self::method();        // текущий класс (раннее связывание)
parent::method();      // родительский класс
static::method();      // фактический класс при вызове (LSB)

// 4. ::class — получить полное имя класса как строку (PHP 5.5+)
echo User::class;        // "App\Models\User"

// Историческое название "::" — Paamayim Nekudotayim (ивр. «двойное двоеточие»);
// если PHP выдаст ошибку "Paamayim Nekudotayim" — это синтаксическая ошибка с ::

class ParentClass {
    public static function testSelf(): string {
        return self::who();      // раннее связывание
    }

    public static function testStatic(): string {
        return static::who();    // позднее (Late Static Binding)
    }

    public static function who(): string {
        return __CLASS__;        // магическая константа: имя текущего класса
    }
}

class ChildClass extends ParentClass {
    public static function who(): string {
        return __CLASS__;
    }
}

echo ChildClass::testSelf();    // "ParentClass"  ← зафиксировано в parent
echo ChildClass::testStatic();  // "ChildClass"   ← фактический класс вызова

// Объяснение:
// self::who() в ParentClass — намертво привязано к ParentClass.
//   Кто бы ни вызывал — всегда parent's who().
// static::who() — динамически определяется во время выполнения.
//   Если вызвано через ChildClass:: — найдёт ChildClass::who().
// Это и есть Late Static Binding (LSB), появился в PHP 5.3.

┌─────────────────────────────────────────────────────────────┐
│ 1. PHP видит вызов: ChildClass::testSelf()                  │
│ 2. Ищет метод testSelf() в ChildClass — НЕТ                 │
│ 3. Поднимается к родителю ParentClass — НАШЁЛ               │
│ 4. Выполняет код тела: return self::who();                  │
│ 5. self → ParentClass (класс ГДЕ ЭТОТ КОД написан)          │
│ 6. Вызывает ParentClass::who() → возвращает 'Parent'        │
│ 7. Итог: echo выводит "Parent"                              │
└─────────────────────────────────────────────────────────────┘

Ключевая мысль: self смотрит на ТЕКСТ кода (где написано),
              а не на КЛАСС, через который сделан вызов.

Метод "переехал" в ChildClass через наследование, но self
по-прежнему указывает на ParentClass — потому что строчка
self::who() физически находится в файле ParentClass.

┌─────────────────────────────────────────────────────────────┐
│ 1. Вызов: ChildClass::testStatic()                          │
│ 2. testStatic() найден в ParentClass (унаследован)          │
│ 3. Выполняется: return static::who();                       │
│ 4. static → ЧТО было слева от :: при вызове = ChildClass    │
│ 5. Ищет who() в ChildClass — НАШЁЛ (переопределён)          │
│ 6. Вызывает ChildClass::who() → возвращает 'Child'          │
│ 7. Итог: echo выводит "Child"                               │
└─────────────────────────────────────────────────────────────┘

Ключевая разница: static — это «класс, через который начался вызов»,
                  а не класс, где написан код.
                  PHP запоминает ChildClass с шага 1
                  и подставляет его в static:: на шаге 4.

class ChildClass extends ParentClass {
    // Если переопределить testSelf() здесь:
    public static function testSelf(): string {
        return self::who();    // теперь self = ChildClass!
    }

    public static function who(): string {
        return 'Child';
    }
}

echo ChildClass::testSelf();   // "Child"
// Потому что self::who() теперь написан внутри ChildClass.
// Главное правило: self указывает на класс, где БУКВАЛЬНО лежит строчка с self.

class BaseModel {
    public static $table = 'base';

    public static function getTable(): string {
        return self::$table;     // self → всегда BaseModel
    }

    public static function getTableLate(): string {
        return static::$table;   // static → класс, через который вызвано
    }
}

class UserModel extends BaseModel {
    public static $table = 'users';    // переопределили
}

echo BaseModel::getTable();      // "base"  — self::$table → BaseModel::$table
echo BaseModel::getTableLate();  // "base"  — static = BaseModel (вызвали от BaseModel)

echo UserModel::getTable();      // "base"  self заблокирован на BaseModel
echo UserModel::getTableLate();  // "users" static подхватил UserModel::$table

+--------------------------------+------+--------------+----------+
| Вызов                          | self | static       | Результат|
+--------------------------------+------+--------------+----------+
| BaseModel::getTable()          | Base | (не использ) | "base"   |
| BaseModel::getTableLate()      | —    | BaseModel    | "base"   |
| UserModel::getTable()          | Base | (не использ) | "base" |
| UserModel::getTableLate()      | —    | UserModel    | "users"|
+--------------------------------+------+--------------+----------+

Колонка "self" — какой класс PHP подставляет под self при выполнении
                 (всегда тот, где написан код = BaseModel).
Колонка "static" — какой класс подставляется под static
                  (тот, через который начали вызов).

UserModel::getTable() возвращает "base" — частая ловушка.
   Программист переопределил $table в UserModel, ожидая что метод
   подхватит новое значение. Но getTable() жёстко смотрит на
   BaseModel::$table из-за self.
Чтобы наследники работали полиморфно — пишите static:: в базовом
   классе для всего, что наследники могут переопределять.

self::    → НЕ полиморфно: всегда берёт из класса, где написан код.
            Удобно когда вы УВЕРЕНЫ что наследники не переопределят.

static::  → ПОЛИМОРФНО: берёт из класса, через который вызвали.
            Используйте в базовом классе для всего, что наследники
            могут менять: $table, $primaryKey, фабричные new static(),
            override-методы вроде find/all/firstOrFail.

// В Eloquent почти все статические методы используют static:: чтобы работать с наследниками

class Model {
    public static function find(int $id): ?static {
        // псевдо-код: достать из БД
        $row = DB::findRow($id);
        return $row ? new static($row) : null;
        //          ↑ new static() — создаёт экземпляр фактического класса
    }
}

class User extends Model {}
class Admin extends User {}

$user  = User::find(1);      // возвращает User
$admin = Admin::find(5);     // возвращает Admin (не User!)

// Если бы в find() было new self() — всегда бы возвращался Model.
// new static() работает полиморфно — это ключ к Eloquent-фабрикам.

class Animal {
    public function describe(): string {
        return "Animal";
    }
}

class Dog extends Animal {
    public function describe(): string {
        return parent::describe() . " → Dog";
        // parent:: — явный вызов реализации родителя
        // Полезно когда переопределяешь метод, но хочешь сохранить базовое поведение
    }
}

(new Dog())->describe();   // "Animal → Dog"

// В конструкторах parent::__construct() — стандартный способ
// инициализировать родителя перед своей логикой:
class SpecialUser extends User {
    public function __construct(string $name, int $level) {
        parent::__construct($name);   // инициализация родителя
        $this->level = $level;
    }
}

class Order {
    const STATUS_PENDING = 'pending';
    const STATUS_PAID    = 'paid';

    // PHP 7.1+ — у констант есть видимость:
    private const MAX_RETRIES = 3;

    // PHP 8.3+ — typed constants:
    const int VERSION = 2;
}

// Доступ через :: (даже у объекта — не через ->):
echo Order::STATUS_PENDING;     // "pending"

$order = new Order();
echo $order::STATUS_PAID;       // "paid" (тоже через :: после объекта)
// echo $order->STATUS_PAID;       — ошибка, через -> только свойства

// Утилитарные функции без состояния
class StringHelper {
    public static function slugify(string $text): string {
        return strtolower(str_replace(' ', '-', $text));
    }
}

// Фабричные методы (named constructors)
class Date {
    public static function today(): static { return new static(date('Y-m-d')); }
    public static function fromString(string $s): static { return new static($s); }
}

// Константы (как enum-замена до PHP 8.1)
class HttpStatus {
    const OK        = 200;
    const NOT_FOUND = 404;
}

// НЕ для сервисов с состоянием — таблица плюсов/минусов:
// Static-сервис:                  Обычный сервис через DI:
//   — невозможно мокать в тестах    + легко мокать
//   — глобальное состояние          + изолированный state
//   — нельзя подменить реализацию   + interface + DI
//   + не надо передавать через DI   — нужно DI-контейнер

// В Laravel почти НИКОГДА не используют свои static-сервисы — все через
// контейнер. Static резервируется для фабрик (Model::find), хелперов
// и фасадов (хотя фасады тоже под капотом обращаются к контейнеру).

// 1. $this в static-методе → Fatal Error
class X {
    public static function f() {
        echo $this->name;   // Fatal: Using $this when not in object context
    }
}

// 2. Свойства через -> вместо ::
Counter::$count++;     // правильно
$counter = new Counter();
$counter->count++;     // ошибка — у объекта нет такого свойства,
                       //    статическое живёт на классе

// 3. Static в Octane / RoadRunner / Swoole — утечка состояния
// В обычном PHP-FPM статика сбрасывается с окончанием процесса.
// В long-running (Octane) статика живёт между запросами:
class UserCache {
    private static array $cache = [];   // под Octane накапливается!
}
// Подробнее в KB_3 (Laravel → Octane).

// 4. self vs static в final-классах
// Если класс final (нельзя наследовать) — self и static идентичны.
// Разница только при наследовании.

// 5. Тестирование static — почти невозможно мокать
// StringHelper::slugify($x) в коде → в тестах нельзя подменить.
// Решение: сделать обычный сервис + interface, инжектить через DI.

+----------------+-------------------------------+--------------------------+
| Конструкция    | Связывание                     | Когда использовать       |
+----------------+-------------------------------+--------------------------+
| self::         | Раннее (класс, где написано)  | Точно знаем класс,       |
|                |                                | не ждём подмены          |
| static::       | Позднее (LSB, класс вызова)   | Наследуемые статические  |
|                |                                | методы, фабрики          |
| parent::       | Родительский класс            | Вызов реализации parent  |
|                |                                | при переопределении      |
| $this->        | Текущий объект                 | Обычные методы           |
| ClassName::    | Явно указанный класс          | Из внешнего кода         |
+----------------+-------------------------------+--------------------------+

Видимость: public, protected, private

class User {
    // public - доступно отовсюду (из класса, подклассов, и снаружи)
    public $name;

    // protected - доступно в классе и подклассах, но НЕ снаружи
    protected $email;

    // private - доступно ТОЛЬКО в этом классе
    private $password;

    public function __construct($name, $email, $password) {
        $this->name = $name;
        $this->email = $email;
        $this->password = $password;
    }

    public function getEmail() {
        return $this->email;  // OK - внутри класса
    }

    protected function verifyPassword($pwd) {
        return $this->password === $pwd;  // OK
    }
}

$user = new User("Alice", "alice@ex.com", "secret");
echo $user->name;  // OK - public
echo $user->email;  // ERROR - protected
echo $user->password;  // ERROR - private

var_dump($user);

// Вывод:
//   object(User)#1 (3) {
//     ["name"]=> string(5) "Alice"                    ← public, обычное имя
//     ["email":protected]=> string(11) "alice@ex.com" ← protected помечен
//     ["password":"User":private]=> string(6) "secret" ← private + ИМЯ КЛАССА
//   }

// Формат ключа в var_dump:
//   "имя"                    — public
//   "имя":protected          — protected
//   "имя":"ИмяКласса":private — private (привязан к конкретному классу!)

Типизированные свойства (PHP 7.4+)

class User
{
    private int $id;                    // без дефолта — должен быть инициализирован до доступа
    private string $name = 'unknown';    // с дефолтом
    private ?int $age = null;             // nullable (?int = int|null)
    private array $items = [];              // массив, дефолт — пустой
    private DateTime $createdAt;            // объект
    private readonly int $constId;       // readonly (PHP 8.1+): записать можно ОДИН раз
}

class User
{
    private int $id;  // нет дефолта
}

$user = new User();
echo $user->id;
// Error: Typed property User::$id must not be accessed before initialization

// Без типа было бы просто null (warning), но с типом — fatal Error.
// Решение: задать дефолт ИЛИ инициализировать в конструкторе.

Naming conventions (PSR-12) — что писать с большой буквы

// Метод в PascalCase — путают с классом
public function AddItem($item) {}

// Метод в camelCase
public function addItem($item) {}


// Метод множественного числа когда добавляет ОДНО
public function addItems($item) {}

// Соответствие имени и действия
public function addItem($item) {}      // один
public function addItems(array $items) {} // несколько


// Класс в lowercase
class user {}

// Класс в PascalCase
class User {}

echo — языковая конструкция, не функция

echo "Hello";                // без скобок
echo "a", "b", "c";          // несколько аргументов через запятую
echo $user->summary();      // цепочка методов — БЕЗ скобок

// Это часто пишут думая что echo — функция:
echo($user)->summary();

// PHP парсит это как:
//   echo  ( ($user)->summary() );
//        ↑ echo принимает ОДНО выражение
//          ($user) — это просто группировка
//          ->summary() — вызов метода на User объекте
//          результат: строка → echo выводит

// Работает СЛУЧАЙНО. Но если попробовать несколько аргументов:
echo($a, $b);
// Parse error! Скобки заставляют PHP интерпретировать как функцию,
// которая не принимает несколько аргументов через запятую.

// Без скобок — работает:
echo $a, $b;  // верно

Глоссарий: Инкапсуляция, Инвариант, DDD, Aggregate Root

class Cart
{
    private array $items = [];

    // Геттер возвращает ССЫЛКУ на массив — внешний код может менять
    public function &getItems(): array
    {
        return $this->items;
    }
}

$cart = new Cart();
$items = &$cart->getItems();
$items[] = 'обход проверок!';
// $items в Cart изменён напрямую, addItem() обойдён.
// private есть, но инвариант не защищён → инкапсуляция СЛАБАЯ.

final class Order
{
    private array $items = [];

    // ─── Команды защищают инварианты ───
    public function addItem(Item $item): void
    {
        // Инвариант 1: не больше 100 товаров
        if (count($this->items) >= 100) {
            throw new DomainException('Лимит товаров');
        }

        // Инвариант 2: товар должен быть в каталоге
        if (!$item->isAvailable()) {
            throw new DomainException('Товар недоступен');
        }

        $this->items[] = $item;
    }

    // ─── Query возвращает COPY, не reference ───
    public function items(): array
    {
        return $this->items;  // PHP передаст копию (CoW для массивов)
    }
}

Aggregate Root — паттерн «инкапсулированное состояние»

final class ShoppingCart
{
    private array $items = [];          // ← ИНКАПСУЛИРОВАННОЕ состояние

    // ─── Команды: МЕНЯЮТ состояние, возвращают void ───
    public function addItem(Item $item): void
    {
        // инварианты проверяются ЗДЕСЬ — не дать положить дубль/невалидное
        if (count($this->items) >= 50) {
            throw new DomainException('Cart full');
        }
        $this->items[] = $item;
    }

    public function removeItem(int $index): void
    {
        unset($this->items[$index]);
        $this->items = array_values($this->items);  // переиндексация
    }

    // ─── Query: ЧИТАЮТ состояние, не меняют ───
    public function total(): float
    {
        return array_sum(array_map(
            fn(Item $i): float => $i->price(),
            $this->items
        ));
    }

    public function isEmpty(): bool
    {
        return $this->items === [];
    }

    public function itemCount(): int
    {
        return count($this->items);
    }
}

// ─── Подход 1: Cached / Materialized — хранить и обновлять ───
final class CartCached
{
    private array $items = [];
    private float $total = 0.0;  // ← храним сумму

    public function addItem(Item $item): void
    {
        $this->items[] = $item;
        $this->total += $item->price();  // синхронизируем
    }

    public function removeItem(int $i): void
    {
        $this->total -= $this->items[$i]->price();  // НЕ ЗАБЫТЬ
        unset($this->items[$i]);
    }

    public function total(): float
    {
        return $this->total;  // O(1) — мгновенно
    }
}

// ─── Подход 2: Computed / Derived — считать каждый раз ───
final class CartComputed
{
    private array $items = [];

    public function addItem(Item $item): void
    {
        $this->items[] = $item;
    }

    public function total(): float
    {
        // O(n) — проходим по items каждый вызов
        return array_sum(array_map(
            fn(Item $i): float => $i->price(),
            $this->items
        ));
    }
}

Constructor Promotion (PHP 8)

// Старый способ (PHP 7)
class User {
    private $id;
    private $name;
    private $email;

    public function __construct(int $id, string $name, string $email) {
        $this->id = $id;
        $this->name = $name;
        $this->email = $email;
    }
}

// Новый способ (PHP 8 - Constructor Promotion)
class User {
    public function __construct(
        private int $id,
        private string $name,
        private string $email
    ) {}
}

// Автоматически создает private свойства и присваивает их!
$user = new User(1, "Alice", "alice@ex.com");

Static методы и свойства

class Counter {
    public static $count = 0;

    public static function increment() {
        self::$count++;
    }

    public static function getCount() {
        return self::$count;
    }
}

// Вызывается через :: оператор, БЕЗ new
Counter::increment();
Counter::increment();
echo Counter::getCount();  // 2

// Практический пример - Factory method в Laravel
class User extends Model {
    public static function findById(int $id) {
        return static::find($id);
    }
}

// Вызов
$user = User::findById(1);

Late Static Binding: static:: vs self::

class BaseModel {
    public static $table = 'base';

    public static function getTable() {
        return self::$table;  // ВСЕГДА вернет 'base'
    }

    public static function getTableLate() {
        return static::$table;  // Полиморфно! Вернет значение вызывающего класса
    }
}

class User extends BaseModel {
    public static $table = 'users';
}

class Post extends BaseModel {
    public static $table = 'posts';
}

User::getTable();      // 'base' (self:: всегда указывает на BaseModel)
User::getTableLate();  // 'users' (static:: указывает на User)

Post::getTableLate();  // 'posts' (static:: указывает на Post)

final и readonly (PHP 8.1+)

class BaseEntity {
    // final метод НЕ МОЖЕТ быть переопределен подклассом
    final public function getId() {
        return $this->id;
    }
}

class User extends BaseEntity {
    public function getId() {  // ERROR!
    }
}

// readonly свойства могут быть установлены ТОЛЬКО в конструкторе
class Product {
    public readonly string $sku;
    public readonly float $price;

    public function __construct(string $sku, float $price) {
        $this->sku = $sku;
        $this->price = $price;
    }
}

$product = new Product("SKU123", 99.99);
$product->price = 50;  // ERROR! readonly свойство

+-------------+--------------------+------------------------------+
| Ключ. слово | К чему применяется | Что запрещает                |
+-------------+--------------------+------------------------------+
| final       | методы, классы     | переопределение метода       |
|             |                    | или наследование класса      |
| readonly    | свойства           | изменение свойства           |
|             |                    | после инициализации          |
+-------------+--------------------+------------------------------+

final НЕ влияет на свойства (нельзя сделать значения "неизменяемыми").
readonly НЕ влияет на методы (нельзя сделать "нельзя переопределить").

final class Money {           // весь класс final
    public function __construct(
        public readonly int    $amount,
        public readonly string $currency,
    ) {}
}

class SpecialMoney extends Money { }
// Fatal error: Class SpecialMoney cannot extend final class Money

// Зачем final class:
// — Value Object (Money, Email, Date) — гарантия что никто не наследует и не сломает инвариант
// — Service classes в DDD/Hexagonal — явная декларация что класс закрыт для расширения
// — Защита от хрупких иерархий: лучше явный отказ от наследования, чем глубокое дерево классов

class Base {
    public readonly int $id;

    public function __construct(int $id) {
        $this->id = $id;
    }
}

class Child extends Base {
    public int $id;            // переобъявили БЕЗ readonly

    public function __construct(int $id) {
        parent::__construct($id);
        $this->id = 999;       // теперь меняется, наследник убрал readonly
    }
}

// PHP 8.4+ ужесточил это правило: readonly свойство в дочернем классе
// обязательно должно остаться readonly. Полный обход через переобъявление
// в большинстве версий работает, но это запах архитектуры.

// Чтобы гарантированно защитить — комбинируйте:
final class UserId {           // final class — нельзя наследовать вообще
    public function __construct(
        public readonly int $value,   // readonly — нельзя изменить
    ) {}
}
// Никто не сможет ни унаследовать, ни обойти readonly через переобъявление.

// Помечает ВСЕ свойства класса как readonly одной декларацией:
readonly class Order {
    public function __construct(
        public int    $id,         // автоматически readonly
        public string $status,     // автоматически readonly
        public int    $totalMinor, // автоматически readonly
    ) {}
}

// Эквивалентно:
// class Order {
//     public function __construct(
//         public readonly int $id,
//         public readonly string $status,
//         public readonly int $totalMinor,
//     ) {}
// }

// Удобно для immutable DTO. Часто комбинируют с final:
final readonly class OrderData { ... }

Наследование и полиморфизм

class Animal {
    public function makeSound(): string {
        return "Какой-то звук";
    }
}

class Dog extends Animal {
    public function makeSound(): string {
        return "Гав!";       // замена реализации родителя
    }
}

class Cat extends Animal {
    public function makeSound(): string {
        return "Мяу!";
    }
}

$animals = [new Dog(), new Cat(), new Animal()];
foreach ($animals as $animal) {
    echo $animal->makeSound() . "\n";
}
// Гав!
// Мяу!
// Какой-то звук

// Это и есть полиморфизм: foreach работает с типом Animal,
// но каждый объект "звучит" по-своему. Без override — все три
// вывели бы "Какой-то звук" (поведение родителя).

class User {
    public function save(): void {
        // базовое сохранение в БД
        DB::insert('users', ['name' => $this->name]);
    }
}

class AuditedUser extends User {
    public function save(): void {
        parent::save();           // сначала обычное сохранение
        AuditLog::record('user.saved', $this->id);  // потом аудит
    }
}

// Логика родителя сохранена + добавлено своё.
// Если бы написали без parent::save() — забыли бы сохранение в БД.

class Controller {
    protected function authorize(string $ability): void {
        abort(403);        // базовая логика: всегда запрещаем
    }
}

class PostController extends Controller {
    protected function authorize(string $ability): void {
        // специализация: админам можно update
        if ($ability === 'update' && auth()->user()->isAdmin()) {
            return;
        }
        parent::authorize($ability);  // остальное — по правилам родителя
    }
}

// Если автор базового класса уверен, что метод НЕ должен меняться
// в наследниках — помечает его final:
class Database {
    final public function connect(): void {
        // жёсткая последовательность подключения, менять опасно
        // (порядок: SSL handshake → auth → set names → setup)
    }
}

class MysqlDatabase extends Database {
    public function connect(): void { }   // Fatal: Cannot override final method
}

// final — способ сказать: "Этот алгоритм критичен, не трогай."

interface PaymentGateway {
    public function charge(int $amount): string;
}

class StripeGateway implements PaymentGateway {
    public function charge(int $amount): string { /* Stripe API */ }
}

class PaddleGateway implements PaymentGateway {
    public function charge(int $amount): string { /* Paddle API */ }
}

class CheckoutService {
    public function __construct(private PaymentGateway $gateway) {}

    public function processOrder(Order $order): string {
        return $this->gateway->charge($order->total);
    }
}

// CheckoutService не знает, Stripe это или Paddle.
// Он работает с КОНТРАКТОМ PaymentGateway, а конкретная реализация
// (полиморфно) определяется тем, что инжектировано через DI.
// Сменили Stripe на Paddle — CheckoutService не трогается ВООБЩЕ.
// Это основа SOLID/DI/тестируемого кода.

class Database {
    final public function connect(): void { ... }
}

class MysqlDatabase extends Database {
    public function connect(): void { }    // Fatal error: Cannot override final method
}
// final — явное запрещение от автора базового класса.

final class Money { ... }

class SpecialMoney extends Money { }
// Fatal: Class SpecialMoney cannot extend final class Money

// Невозможно даже создать подкласс — значит и override невозможен.
// Часто применяется для Value Object: Money, Email, UserId.

class Base {
    private function hidden(): string { return "base"; }

    public function callHidden(): string {
        return $this->hidden();   // всегда вызовет Base::hidden(), не Child!
    }
}

class Child extends Base {
    private function hidden(): string { return "child"; }
    // Синтаксически разрешено, но это ОТДЕЛЬНЫЙ метод в Child.
    // Base::callHidden() о нём не знает.
}

echo (new Child())->callHidden();   // "base" — не "child"!

// Это частая ловушка: private методы НЕ наследуются по-настоящему.
// Они "приватны для класса", где объявлены. Подкласс может только
// СОЗДАТЬ свой private-метод с тем же именем — но это не override.
// Решение: используйте protected, если хотите чтобы наследники могли подменить.

// Даже если метод не final и не private, PHP проверяет совместимость сигнатуры.
// Правила (часть LSP — Liskov Substitution Principle):
//   — visibility можно РАСШИРИТЬ (protected → public), но НЕ СУЗИТЬ
//   — параметры: contravariant (тот же или шире/менее строгий тип)
//   — return type: covariant (тот же или уже/более строгий тип)
//   — нельзя поменять static/non-static

class Animal {
    public function eat(Food $f): Food { ... }
}

class Dog extends Animal {
    // Сужение видимости — Fatal Error
    protected function eat(Food $f): Food { ... }

    // Несовместимый тип параметра (более узкий, не contravariant)
    public function eat(DogFood $f): Food { ... }

    // Меняем static на не-static
    public static function eat(Food $f): Food { ... }

    // Уточнение return type (covariant) — разрешено
    public function eat(Food $f): DogFood { ... }

    // Расширение visibility — разрешено
    public function eat(Food $f): Food { ... }  // если в Animal был protected
}

class A {
    public static function test(): string { return "A"; }
}

class B extends A {
    public static function test(): string { return "B"; }   // разрешено
}

B::test();   // "B"

// Технически разрешено. НО это не классический полиморфизм — нет $this,
// связывание ранее (через self::) идёт к классу, где метод написан.
// Для полиморфизма со static-методами используйте static:: (Late Static Binding,
// см. предыдущую подсекцию про self/static).

// А вот final static — переопределить нельзя:
class A {
    final public static function test(): string { return "A"; }
}
class B extends A {
    public static function test(): string { return "B"; }   // Fatal
}

class User { }

class Admin extends User {
    public function banUser(): void { ... }   // в User такого метода нет — это новый метод, не override
}

// PHP не выдаёт ошибки, но семантически — это extension, не overriding.
// Иногда в IDE/линтерах настраивают атрибут #[\Override] (PHP 8.3+):

class Cat extends Animal {
    #[\Override]
    public function makeSound(): string { return "Мяу"; }   // если в Animal есть makeSound

    #[\Override]
    public function makesSound(): string { ... }   опечатка!
    // PHP кинет Fatal — метода makesSound нет в родителе.
    // Атрибут #[\Override] защищает от случайных опечаток и от ситуаций,
    // когда родитель переименовал метод, а наследник остался со старым именем.
}

+-----------------------------------+----------------------+--------------------+
| Условие                           | Можно ли override?   | Что произойдёт     |
+-----------------------------------+----------------------+--------------------+
| Метод final в родителе            | нет                | Fatal Error        |
| Класс final                       | нельзя наследовать | Fatal Error        |
| Метод private                     | синтаксически да,  | НЕ override —      |
|                                   |   но это не override | новый метод в      |
|                                   |                      | дочернем           |
| Сужение visibility                | нет                | Fatal Error        |
| Несовместимый тип параметра       | нет                | Fatal Error        |
| Несовместимый return type         | нет (без covariance)| Fatal Error       |
| Меняем static/non-static          | нет                | Fatal Error        |
| Метод protected/public, не final  | да                  | работает           |
| static (не final)                 | да, но не полиморф | работает           |
| Метода нет в родителе             | да, но это новый,  | предупреждение     |
|                                   |   не override        | если #[\Override]  |
+-----------------------------------+----------------------+--------------------+

class Animal {
    protected $name;

    public function __construct(string $name) {
        $this->name = $name;
    }

    public function sound() {
        return "Some sound";
    }

    public function introduce() {
        return "I am " . $this->name;
    }
}

class Dog extends Animal {
    public function sound() {
        return "Woof!";  // Переопределение
    }
}

class Cat extends Animal {
    public function sound() {
        return "Meow!";  // Переопределение
    }
}

// Полиморфизм - один интерфейс, разные поведения
makeSound(new Dog("Rex"));  // "Woof!"
makeSound(new Cat("Whiskers"));  // "Meow!"

function makeSound(Animal $animal) {
    echo $animal->sound();
}

// Вызов родительского метода через parent::
class Dog extends Animal {
    public function introduce() {
        return parent::introduce() . " and I'm a dog!";
    }
}

Абстрактные классы

abstract class Repository {
    protected $db;

    // Конкретный метод - имеет реализацию
    public function setDb($db) {
        $this->db = $db;
    }

    // Абстрактный метод - должен быть реализован подклассом
    abstract public function findById(int $id);

    // Абстрактный метод
    abstract public function getAll();
}

class UserRepository extends Repository {
    public function findById(int $id) {
        return $this->$db->query("SELECT * FROM users WHERE id = ?", [$id]);
    }

    public function getAll() {
        return $this->$db->query("SELECT * FROM users");
    }
}

$repo = new Repository();  // ERROR! Cannot instantiate abstract class
$repo = new UserRepository();  // OK

abstract class Animal {
    protected string $name;

    public function __construct(string $name) {
        $this->name = $name;
    }

    // Готовый метод — все наследники получают бесплатно
    public function getName(): string {
        return $this->name;
    }

    // Абстрактный — каждый наследник обязан реализовать по-своему
    abstract public function makeSound(): string;
}

class Dog extends Animal {
    public function makeSound(): string { return "Гав!"; }
}

class Cat extends Animal {
    public function makeSound(): string { return "Мяу!"; }
}

// $animal = new Animal("Test");   // Fatal: Cannot instantiate abstract class

$dog = new Dog("Бобик");
echo $dog->getName();     // "Бобик" — унаследовано
echo $dog->makeSound();   // "Гав!"  — собственная реализация

// Каркас алгоритма фиксирован в родителе; шаги — в наследниках

abstract class CrudController extends Controller {
    // Наследники обязаны указать модель и правила
    abstract protected function modelClass(): string;
    abstract protected function validationRules(Request $r): array;

    // Общая логика для всех CRUD-контроллеров — пишется один раз
    public function store(Request $request): JsonResponse {
        $validated = $request->validate($this->validationRules($request));
        $item = ($this->modelClass())::create($validated);
        return response()->json($item, 201);
    }

    public function index(): JsonResponse {
        return response()->json(($this->modelClass())::all());
    }
}

class UserController extends CrudController {
    protected function modelClass(): string { return User::class; }

    protected function validationRules(Request $r): array {
        return ['name' => 'required|string', 'email' => 'required|email|unique:users'];
    }
}

class ProductController extends CrudController {
    protected function modelClass(): string { return Product::class; }

    protected function validationRules(Request $r): array {
        return ['title' => 'required|string|max:100', 'price' => 'required|numeric|min:0'];
    }
}

// Зачем абстрактный: store() и index() пишутся ОДИН раз в CrudController.
// Каждый наследник лишь указывает модель и правила. Если завтра добавится
// логирование запросов — добавляется в одном месте, работает для всех.

abstract class NotificationService {
    public function __construct(
        protected string $recipient,
        protected string $message,
    ) {}

    // Каркас: каждый наследник делает свой send()
    abstract public function send(): bool;

    // Общая утилита — все наследники переиспользуют
    protected function log(string $status): void {
        Log::info("[$status] Sent to $this->recipient");
    }
}

class EmailService extends NotificationService {
    public function send(): bool {
        $ok = Mail::to($this->recipient)->send(new GenericMail($this->message));
        $this->log($ok ? 'OK' : 'FAIL');
        return $ok;
    }
}

class SmsService extends NotificationService {
    public function send(): bool {
        $ok = Http::post('https://sms.api/send', [...])->successful();
        $this->log($ok ? 'OK' : 'FAIL');
        return $ok;
    }
}

// Полиморфное использование — код не знает, какой именно сервис
$notifications = [
    new EmailService('a@ex.com', 'Hi'),
    new SmsService('+1234', 'Hi'),
];
foreach ($notifications as $n) {
    $n->send();   // каждый отрабатывает по-своему, логирование общее
}

use Illuminate\Database\Eloquent\Model;

abstract class BaseEntity extends Model {
    // Наследник указывает по какому полю искать (slug, username, etc.)
    abstract public function searchField(): string;

    // Универсальный поиск — работает для всех наследников
    public static function findByUnique(string $value): ?static {
        $instance = new static();
        return static::where($instance->searchField(), $value)->first();
    }

    // Общий аксессор для формата даты — у всех моделей
    public function createdAtShort(): string {
        return $this->created_at->format('d.m.Y');
    }
}

class Article extends BaseEntity {
    public function searchField(): string { return 'slug'; }
}

class User extends BaseEntity {
    public function searchField(): string { return 'username'; }
}

// Полиморфно — Article ищется по slug, User по username
$article = Article::findByUnique('hello-world');
$user    = User::findByUnique('john_doe');

// findByUnique() написан 1 раз; каждый наследник без копипасты получает поиск.

// PHP в SPL даёт абстрактный FilterIterator — пишешь свой class extends...
// и обязательно реализуешь accept().

abstract class FilterIterator extends IteratorIterator {
    // Этот метод сам PHP вызывает на каждой итерации,
    // и наследник ОБЯЗАН его реализовать
    abstract public function accept(): bool;
}

// Свой фильтр — оставляет только строки длиннее N символов
class MinLengthFilter extends FilterIterator {
    public function __construct(Iterator $it, private int $min) {
        parent::__construct($it);
    }

    public function accept(): bool {
        return strlen((string) $this->current()) >= $this->min;
    }
}

$words    = new ArrayIterator(['a', 'hi', 'apple', 'no', 'banana']);
$filtered = new MinLengthFilter($words, 3);

foreach ($filtered as $w) echo $w . "\n";
// apple
// banana
// (короткие отфильтрованы PHP-движком, мы дали только правило)

+-------------------------+--------+--------+----------+
| Характеристика          | Class  | Abstr. | Interface|
+-------------------------+--------+--------+----------+
| new ClassName()         |      |     |       |
| Готовые методы          |      |      | (PHP<8.1)|
| Абстрактные методы      |     |      | (по сути)|
| Свойства/поля           |      |      |       |
| Конструктор             |      |      |       |
| Множественное наследов. | 1 родит| 1 родит| много    |
| Константы               |      |      |        |
| Тип в type hint         |      |      |        |
+-------------------------+--------+--------+----------+

Интерфейсы (Interfaces)

interface Loggable {
    public function log(string $message);
}

interface Cacheable {
    public function cache(string $key, $value);
    public function getCache(string $key);
}

// Класс может имплементировать несколько интерфейсов
class UserService implements Loggable, Cacheable {
    private $cache = [];

    public function log(string $message) {
        echo "LOG: " . $message;
    }

    public function cache(string $key, $value) {
        $this->$cache[$key] = $value;
    }

    public function getCache(string $key) {
        return $this->$cache[$key] ?? null;
    }
}

$service = new UserService();
$service->log("User created");
$service->cache("user:1", "John");

Когда использовать Абстрактные классы vs Интерфейсы

// Абстрактный класс для иерархии: Animal -> Dog -> GoldenRetriever
abstract class Animal {}
class Dog extends Animal {}
class GoldenRetriever extends Dog {}

// Интерфейсы для способностей
interface Trainable {}
interface Loveable {}

// Dog может быть Trainable И Loveable
class Dog extends Animal implements Trainable, Loveable {
    public function train() {}
    public function love() {}
}

Default Methods в интерфейсах (PHP 8.1+)

interface Repository {
    public function findById(int $id);

    // Default реализация метода в интерфейсе
    public function count() {
        return count($this->getAll());
    }
}

class UserRepository implements Repository {
    public function findById(int $id) {
        // реализация
    }

    // count() унаследуется с default реализацией
}

Trait vs Abstract Class vs Interface — сравнение

// ABSTRACT CLASS — общий родитель с базовой логикой и данными
// Используй когда: есть иерархия "is-a" и общее состояние
abstract class Animal {
    protected string $name;            // общее состояние
    public function eat() { /* общее поведение */ }
    abstract public function sound(): string;  // подкласс ОБЯЗАН
}

// INTERFACE — контракт способностей, без реализации
// Используй когда: нужно описать capability для type-hint
interface Trainable {
    public function learn(string $command): void;
}

// TRAIT — переиспользуемое поведение для классов разных веток
// Используй когда: один и тот же метод нужен в неродственных классах
trait Loggable {
    public function log(string $msg): void {
        error_log(static::class . ": $msg");
    }
}

// КОМБИНАЦИЯ — реальный код часто использует все три
class Dog extends Animal implements Trainable {
    use Loggable;

    public function sound(): string { return "Woof"; }
    public function learn(string $cmd): void { $this->log("Learned $cmd"); }
}

Основы Traits

trait Timestamp {
    public $createdAt;
    public $updatedAt;

    public function setTimestamps() {
        $this->createdAt = new DateTime();
        $this->updatedAt = new DateTime();
    }
}

trait SoftDelete {
    public $deletedAt;

    public function softDelete() {
        $this->deletedAt = new DateTime();
    }

    public function restore() {
        $this->deletedAt = null;
    }
}

class Post {
    use Timestamp, SoftDelete;

    private $title;

    public function __construct(string $title) {
        $this->title = $title;
        $this->setTimestamps();  // From Timestamp trait
    }
}

$post = new Post("Hello");
$post->softDelete();  // From SoftDelete trait

Разрешение конфликтов: insteadof и as

trait A {
    public function handle() {
        echo "Trait A";
    }
}

trait B {
    public function handle() {
        echo "Trait B";
    }
}

class MyClass {
    use A, B {
        // insteadof - выбрать один метод, другой игнорировать
        B::handle insteadof A;
        // as - создать алиас для метода A (переименовать)
        A::handle as handleA;
    }
}

$obj = new MyClass();
$obj->handle();   // "Trait B"
$obj->handleA();  // "Trait A"

Абстрактные методы в Traits

trait Validatable {
    // Абстрактный метод - подклассы ДОЛЖНЫ реализовать
    abstract public function rules();

    // Конкретный метод, который использует абстрактный
    public function validate($data) {
        $rules = $this->rules();
        // Валидировать $data против $rules
    }
}

class UserForm {
    use Validatable;

    public function rules() {
        return [
            'email' => 'required|email',
            'password' => 'required|min:8'
        ];
    }
}

Реальные use cases Traits

// 1. Логирование для разных классов
trait Loggable {
    public function log($msg) {
        echo date('Y-m-d H:i:s') . ": " . $msg;
    }
}

class UserService { use Loggable; }
class OrderService { use Loggable; }

// 2. Кэширование для модели
trait Cacheable {
    private $cache = [];

    public function remember($key, callable $callback) {
        if (isset($this->cache[$key])) {
            return $this->cache[$key];
        }
        return $this->cache[$key] = $callback();
    }
}

// 3. JSON сериализация
trait JsonSerializable {
    public function toJson() {
        return json_encode($this->toArray());
    }

    abstract public function toArray();
}

Пояснялка — частые вопросы по разделу

① Что такое isset в trait Cacheable?
В фрагменте кода if (isset($this->cache[$key])) — это встроенная языковая конструкция PHP (не часть trait). Она проверяет, что элемент массива $this->cache с ключом $key существует И не равен null. В контексте трейта Cacheable логика такая: если ключ есть → вернуть закэшированное значение (без повторного вычисления); если нет → вызвать $callback(), сохранить результат в $cache[$key] и вернуть.

② Почему именно isset, а не array_key_exists?
isset($this->cache[$key]) вернёт true, только если элемент существует и его значение не null. Если кэшируемая функция может вернуть null, то isset ошибочно решит, что кэша нет, и вызовет $callback() повторно. В таких случаях лучше array_key_exists($key, $this->cache) — он проверяет только наличие ключа. Автор трейта, вероятно, исходит из того, что $callback() никогда не возвращает null, либо такое поведение допустимо.

③ Метод validate() из trait — обязательно реализовывать в классе?
Нет. validate() в trait уже имеет готовую реализацию — она «вмешивается» в класс через use Validatable. Класс UserForm получает её бесплатно и может вызвать $form->validate($data) без переопределения. Обязателен только rules() — у него abstract модификатор. Trait декларирует: «я умею валидировать, но правила задаёт класс-пользователь». Если класс не реализует rules() — fatal error:

Fatal error: Class UserForm contains 1 abstract method
and must therefore be declared abstract or implement
the remaining methods (Validatable::rules)

Возможные сценарии для класса с trait:

• Abstract метод trait (rules()) — обязан реализовать класс.
• Concrete метод trait (validate()) — не обязан, наследует as-is. Может переопределить, если хочет другую логику.
• Свойство trait ($cache) — попадает в класс автоматически.

Это та же логика, что у abstract class: abstract method = контракт, concrete method = бесплатное наследство.

④ Интерфейсы могут хранить свойства?
Нет — интерфейс не может содержать свойства (поля). Только сигнатуры методов (и, в некоторых случаях, константы). Он говорит: «Класс, который меня реализует, обязан иметь такие-то методы», но как эти методы будут работать и какие внутренние свойства для этого понадобятся — решает сам класс.

interface CacheableInterface {
    public function remember($key, callable $callback);
}

// Класс сам решает, хранить ли кэш в свойстве $cache, в БД, в Redis и т.д.
class UserService implements CacheableInterface {
    private $cache = []; // ← свойство придумал класс, интерфейс его не требует
    public function remember($key, callable $callback) { /* ... */ }
}

⑤ Трейты могут хранить свойства? Можно ли их изменить в классе?
Да — трейт может определять свойства (поля) с любым модификатором (public, protected, private). Когда класс подключает трейт через use, все эти свойства становятся частью класса, как будто они были написаны прямо в классе.

Что значит «класс может изменить их»?

• Изменить значения свойств — да, легко. Класс может перезаписать $this->cache = [] в своём методе.
• Изменить само объявление (видимость private на protected, тип или значение по умолчанию) — так просто не выйдет. Если класс повторно объявит свойство с тем же именем, PHP выдаст ошибку, если объявления несовместимы. Можно переопределить метод, который работает со свойством, или использовать механизм insteadof / as — но для свойств это редко и сложно.

Правильнее сказать: трейт даёт классу готовые свойства, а класс может использовать и модифицировать их значения, но не может «отменить» или «изменить сигнатуру» самого свойства без конфликта.

⑥ Ограничения trait Cacheable

• Свойство private $cache — область видимости private внутри трейта, но оно становится частью класса, использующего трейт. Если в классе уже есть свойство $cache — конфликт (его можно разрешить в классе).
• Кэш живёт только в пределах одного запроса (in-memory, не сохраняется между HTTP-запросами).
• Для долговременного кэширования (Redis, memcached) — этот трейт не подходит. Используй Cache::remember().

__construct и __destruct

class Database {
    private $connection;

    // __construct вызывается при создании объекта
    public function __construct(string $host, string $user) {
        $this->connection = mysqli_connect($host, $user);
        echo "Connected";
    }

    // __destruct вызывается при удалении объекта
    public function __destruct() {
        mysqli_close($this->connection);
        echo "Disconnected";
    }
}

$db = new Database("localhost", "root");
// Output: "Connected"
$db = null;  // или выход из области видимости
// Output: "Disconnected"

// 1. FileHandler — открыть/закрыть файл автоматически
class FileHandler {
    private $handle;
    private string $path;

    public function __construct(string $path, string $mode = 'r') {
        $this->path = $path;
        $this->handle = fopen($path, $mode);
        if (!$this->handle) throw new Exception("Cannot open file");
    }

    public function read(): string {
        return fread($this->handle, filesize($this->path));
    }

    public function __destruct() {
        if ($this->handle) fclose($this->handle);  // гарантированно закроется
    }
}

// 2. FileLock — захват/освобождение файловой блокировки
class FileLock {
    private $handle;

    public function __construct(string $file) {
        $this->handle = fopen($file, 'c');
        flock($this->handle, LOCK_EX);  // эксклюзивная блокировка
    }

    public function __destruct() {
        flock($this->handle, LOCK_UN);
        fclose($this->handle);
    }
}

// 3. Logger — открыть лог, дописать стартовую/финальную запись
class Logger {
    private $logFile;

    public function __construct(string $filename) {
        $this->logFile = fopen($filename, 'a');
        $this->write("Logger started");
    }

    public function write(string $message): void {
        fwrite($this->logFile, date('Y-m-d H:i:s') . " - $message\n");
    }

    public function __destruct() {
        $this->write("Logger finished");
        fclose($this->logFile);
    }
}

// 4. TransactionGuard — гарантированный rollback при сбое
class TransactionGuard {
    public function __construct(private PDO $db) {
        $this->db->beginTransaction();
    }

    public function commit(): void { $this->db->commit(); }

    public function __destruct() {
        // если commit не был вызван — откатываем
        if ($this->db->inTransaction()) $this->db->rollBack();
    }
}

// Использование:
function transfer(PDO $db): void {
    $tx = new TransactionGuard($db);
    // ... любой throw здесь автоматически откатит транзакцию через __destruct
    $tx->commit();
}

__get, __set, __isset, __unset

class User {
    private $data = [];

    // Вызывается при доступе к приватному/несуществующему свойству
    public function __get(string $name) {
        echo "Getting $name";
        return $this->data[$name] ?? null;
    }

    // Вызывается при установке приватного/несуществующего свойства
    public function __set(string $name, $value) {
        echo "Setting $name to $value";
        $this->data[$name] = $value;
    }

    // Вызывается при isset() на приватном свойстве
    public function __isset(string $name) {
        return isset($this->data[$name]);
    }

    // Вызывается при unset() на приватном свойстве
    public function __unset(string $name) {
        unset($this->data[$name]);  // удалить ключ из внутреннего массива
    }
}

$user = new User();
$user->name = "Alice";      // Вызовет __set
echo $user->name;          // Вызовет __get
isset($user->name);        // Вызовет __isset

$user = new User();

$user->name = "Alice";
// PHP: нет свойства $name → __set('name', 'Alice') → $data['name'] = 'Alice'

echo $user->name;
// PHP: нет свойства $name → __get('name') → return $data['name'] = 'Alice'

var_dump(isset($user->name));
// PHP: нет свойства $name → __isset('name') → isset($data['name']) = true

unset($user->name);
// PHP: нет свойства $name → __unset('name') → unset($data['name'])

var_dump(isset($user->name));
// PHP: → __isset('name') → false (ключ удалён из $data)

__call и __callStatic

class Builder {
    private $query = [];

    // __call - вызывается для приватных/несуществующих методов
    public function __call(string $name, $args) {
        $this->query[$name] = $args[0] ?? null;
        return $this;  // Fluent interface
    }

    // __callStatic - статический вызов несуществующего метода
    public static function __callStatic(string $name, $args) {
        return new self()->__call($name, $args);
    }

    public function get() {
        return $this->query;
    }
}

// Создается dynamic методы: select, where, orderBy
$builder = new Builder();
$builder->select('*')->where('id = 1')->orderBy('name');
print_r($builder->get());
// ['select' => '*', 'where' => 'id = 1', 'orderBy' => 'name']

__toString, __invoke, __clone

class Price {
    public function __construct(float $amount) {
        $this->amount = $amount;
    }

    // __toString - преобразование объекта в строку
    public function __toString() {
        return sprintf('$%.2f', $this->amount);
    }

    // __invoke - позволяет вызвать объект как функцию
    public function __invoke(float $percent) {
        return $this->amount * (1 + $percent / 100);
    }

    // __clone - вызывается при клонировании объекта
    public function __clone() {
        echo "Cloning price object";
    }
}

$price = new Price(99.99);
echo $price;  // "$99.99" (вызовет __toString)
echo $price(10);  // 109.989 (вызовет __invoke с 10% скидка)
$copy = clone $price;  // Вызовет __clone

__debugInfo и __serialize

class User {
    private $id = 1;
    private $password = 'secret';
    public $name = 'Alice';

    // __debugInfo - контролирует что показывается в var_dump/print_r
    public function __debugInfo() {
        return [
            'id' => $this->id,
            'name' => $this->name,
            // password скрыт!
        ];
    }

    // __serialize - контролирует сериализацию (PHP 7.4+)
    public function __serialize() {
        return [
            'id' => $this->id,
            'name' => $this->name
            // password НЕ сериализуется
        ];
    }

    // __unserialize - восстановление из сериализации
    public function __unserialize($data) {
        $this->id = $data['id'];
        $this->name = $data['name'];
    }
}

Пояснялка — частые вопросы по разделу

① Откуда в примере Database берутся $host, $user и $connection?
Распространённое замешательство: в коде класса нет видимого определения $host и $user. Они не являются полями класса — они приходят извне.

• $host, $user — параметры конструктора. Не определены где-то заранее. Получают значения в момент создания объекта: $db = new Database("localhost", "root") — «localhost» становится $host, «root» становится $user.
• $connection — свойство класса (private $connection;). Внутри конструктора выполняется $this->connection = mysqli_connect($host, $user). Функция mysqli_connect() открывает реальное TCP-соединение с сервером MySQL и аутентифицируется. Возвращает объект-ссылку на соединение, который сохраняется в свойстве.
• Связь с БД: mysqli_connect() внутри устанавливает TCP-соединение с MySQL по указанному хосту (localhost = сокет или 127.0.0.1:3306) и аутентифицируется с указанным пользователем. Если пароль не передан, PHP попытается подключиться без пароля — сработает только если у пользователя действительно нет пароля.
• В реальных проектах параметры обычно читаются из .env / config.php и передаются в конструктор. Это стандартный приём: класс не знает, какой именно хост и пользователь будут использоваться — это решает тот, кто создаёт объект.
• Опечатка-капкан: в исходном коде было написано $this->$connection (с двумя $). Правильно: $this->connection (без лишнего $ после ->). $this->$connection — это обращение к свойству, имя которого хранится в переменной $connection (variable property). Если переменная не определена — fatal error.

② Что значит «несуществующее свойство» для __get/__set/__isset/__unset?
Это свойство, которое явно не объявлено в классе (нет ни public $name, ни protected $name, ни private $name). В примере класса User есть только private $data — свойства $name у класса нет, но обращение $user->name = "Alice" работает благодаря __set.