Карта знаний PHP — ornith-1.5:35b, run-06 · think: low

{"answer": "нет", "пояснение": "Строки в двойных кавычках интерпретируют переменные ($var) и служебные символы (\\n, \\t и т.д.), а строки в одинарных кавычках воспринимаются буквально без обработки."}

{"answer": "да", "пояснение": "Оператор ?? (null coalescing) действительно работает по семантике isset: он проверяет, определена ли переменная и не равна ли null, и не генерирует предупреждений для неопределённых переменных."}

{"answer": "ab", "пояснение": "echo принимает несколько аргументов через запятую и выводит их подряд без разделителя, поэтому 'a' и 'b' склеиваются в 'ab'."}

{"answer": "да", "пояснение": "print — языковая конструкция, которая всегда возвращает 1 и, поскольку возвращает значение, может использоваться внутри выражений."}

{"answer": "нет", "пояснение": "Оператор ?: (элвис) возвращает левый operando, если он истинный (truthy), а не ложный; если левый операнд ложный, возвращается правый operando."}

{"answer": "да", "пояснение": "В PHP операторы сложения (+) и вычитания (-) имеют более высокий приоритет, чем конкатенация (.), поэтому выражение \"a\". \"b\" + \"c\" сначала выполняет сложение."}

{"answer": "нет", "пояснение": "В PHP оператор ** имеет правостороннюю ассоциативность, поэтому 2 ** 3 ** 2 вычисляется как 2 ** (3 ** 2) = 2 ** 9 = 512, а не 64."}

{"answer": "3", "пояснение": "Операторы конкатенации и сложения имеют одинаковый приоритет и левую ассоциативность, поэтому сначала вычисляется «сумма: » . 2 = строка «сумма: 2», затем 0 + 3 = 3, так как нечисловая строка приводится к 0."}

{"answer": "нет", "пояснение": "При строгом сравнении === массивы равны только если они имеют одинаковые пары ключ-значение в том же порядке, поэтому порядок элементов имеет значение."}

{"answer": "нет", "пояснение": "Оператор == — это нестрогое (не строгое) сравнение, и выражение 0 == false истинно, так как 0 приводится к false."}

{"answer": "да", "пояснение": "Поскольку строка \"abc\" не является числовой, при нестрогом сравнении со 0 она приводится к 0, поэтому 0 == 0 даёт true."}

```json ⏎ {"answer": "да", "пояснение": "В PHP значение null при нестрогом сравнении (==) действительно равно одновременно 0, пустой строке '' и false."} ⏎ ```

{"answer": 42, "пояснение": "При приведении строки к int PHP берёт ведущее числовое значение строки, игнорируя нечисовые символы после него."}

{"answer": "10", "пояснение": "PHP приводит строку '5' к числу при арифметической операции с целым числом 5, в результате получается 10."}

{"answer": "нет", "пояснение": "В PHP при приведении false к строке получается пустая строка \"\", а не \"0\"; только true преобразуется в \"1\"."}

{"answer": "да", "пояснение": "Из-за особенностей хранения числов с плавающей точкой 0.1 + 0.2 даёт 0.30000000000000004, а не точное 0.3, поэтому строгое сравнение возвращает false."}

{"answer": "нет", "пояснение": "strrev() переворачивает строку побайтово, поэтому многобайтные символы UTF-8 будут разобраны неправильно и строка исказится."}

{"answer": "да", "пояснение": "Функция str_contains() возвращает true, если подстрока 'world' действительно содержится в 'Hello world'."}

{"answer": "нет", "пояснение": "str_pad() может дополнять строку слева (STR_PAD_LEFT), справа (STR_PAD_RIGHT) и с обеих сторон (STR_PAD_BOTH) с помощью параметра pad_type."}

{"answer": "нет", "пояснение": "По умолчанию trim() срезает не только пробелы, но и табы, переводы строк, а также NUL-байты и вертикальные табы."}

{"answer": 12, "пояснение": "strlen считает байты, а не символы; слово 'привет' состоит из 6 кириллических символов, каждый в UTF-8 занимает 2 байта, что даёт 12 байтов."}

{"answer": "def", "пояснение": "Отрицательный смещение в substr отсчитывает символы с конца строки, поэтому -3 означает начало с символа 'd', и возвращается 'def'."}

{"answer": "нет", "пояснение": "ucfirst() не изменяет исходную строку на месте, а возвращает новую строку с большой первой буквой, так как в PHP строки передаются по значению."}

{"answer": "да", "пояснение": "Heredoc поддерживает интерполяцию переменных, аналогично двойным кавычкам, а Nowdoc не выполняет интерполяцию, аналогично одинажным кавычкам."}

{"answer": "нет", "пояснение": "Функция sort() сортирует элементы по значениям и пересчитывает (нумерует заново) числовые ключи, поэтому связь исходных ключей со значениями теряется."}

{"answer": "да", "пояснение": "В PHP строковый ключ, являющийся целым числом (например '5'), автоматически приводится к типу int, поэтому ключ '5' и 5 ссылаются на один и тот же элемент массива."}

{"answer": "нет", "пояснение": "По умолчанию in_array() использует нестрогое сравнение (==), строгое сравнение применяется только при передаче третьего параметра $strict = true."}

{"answer": "да", "пояснение": "Если callback не передан, array_filter() по умолчанию отфильтровывает все «пустые» (falsy) элементы: '', 0, 0.0, '0', null, false, []."}

```json ⏎ {"answer": "нет", "пояснение": "По умолчанию array_slice() перенумеровывает числовые ключи с нуля, параметр preserve_keys по умолчанию равен false."} ⏎ ```

{"answer": "[20, 30]", "пояснение": "array_slice начинает сдвигать массив с индекса 1 (элемент 20) и берёт 2 элемента: 20 и 30."}

{"answer": 2, "пояснение": "Оператор + объединяет массивы, но элементы левого массива с совпадающими ключами не перезаписываются, а новые ключи правого массива добавляются, поэтому результат — ['a' => 1, 'b' => 2]."}

{"answer": "да", "пояснение": "Начиная с PHP 8.1 spread-оператор в литерале массива корректно сливает ключи со строками, а до этой версии с ключами-строками вел себя некорректно."}

{"answer": "нет", "пояснение": "В PHP разрешено совмещать именованные аргументы со spread-распаковкой массива, например foo(c: 3, ...$args) работает корректно."}

{"answer": "да", "пояснение": "Аноимные функции (замыкания) в PHP автоматически наследуют переменные из родительской области видимости, поэтому без use они их видят (но по значению, а не по ссылке)."}

{"answer": 3, "пояснение": "func_num_args() возвращает фактическое количество переданных аргументов, а не количество объявленных параметров, поэтому для f(1, 2, 3) это будет 3."}

{"answer": "да", "пояснение": "Стрелочные функции в PHP могут использовать тело в фигурных скобках, содержащее несколько операторов, хотя в короткой форме (без скобок) возвращается только одно выражение."}

{"answer": "нет", "пояснение": "Стрелочные функции fn захватывают внешние переменные по значению, а не по ссылке, поэтому изменения внешней переменной внутри них не отражаются."}

{"answer": "да", "пояснение": "Статическое замыкание не привязано к экземпляру класса, поэтому оно не имеет доступа к $this."}

{"answer": "5", "пояснение": "При использовании use ($x) значение переменной захватывается по значению в момент создания замыкания, поэтому последующее изменение $x = 7 на замыкание не влияет."}

{"answer": "да", "пояснение": "В слабом режиме типизации PHP выполняет принудительное приведение (coercion) скалярных типов, поэтому строку \"5\" можно передать в параметр с типом int."}

{"answer": "да", "пояснение": "Промоция свойств в конструкторе добавлена в PHP 8.0 и позволяет объявлять и инициализировать свойства прямо в параметрах конструктора."}

{"answer": "final", "пояснение": "Ключевое слово final запрещает наследникам переопределять метод или расширять класс."}

{"answer": "да", "пояснение": "Методы, объявленные как final, запрещено переопределять в подклассах — это запрещено на уровне языка PHP."}

{"answer": "нет", "пояснение": "Private-свойства доступны только внутри класса, в котором они объявлены, и недоступны для наследников — для этого предназначен protected."}

{"answer": "@anonymous", "пояснение": "Имя анонимного класса в PHP имеет вид \"@anonymous\\0<путь_к_файлу><строка>\", поэтому до нулевого байта находится \"@anonymous\"."}

{"answer": "да", "пояснение": "Приватные методы родителя не наследуются и не входят в контракт, поэтому потомок может объявить метод с тем же именем с любой видимостью без ошибки."}

{"answer": "нет", "пояснение": "Магический метод __get() вызывается не только для несуществующих, но и для защищённых (protected) и приватных (private) свойств, доступ к которым осуществляется из недопустимой области видимости."}

{"answer": "Error", "пояснение": "Повторное присваивание readonly-свойства в PHP 8.1+ вызывает ошибку типа Error (Fatal Error: Cannot modify readonly property), а не Exception."}

{"answer": "да", "пояснение": "В PHP интерфейсы могут объявлять константы, которые затем используются как interface::CONSTANT."}

{"answer": "instanceof", "пояснение": "Оператор instanceof проверяет, является ли объект экземпляром указанного класса или реализует ли он указанный интерфейс."}

{"answer": "да", "пояснение": "С PHP 8.0 интерфейсы могут объявлять статические методы."}

{"answer": "нет", "пояснение": "Оператор instanceof в PHP также проверяет, является ли объект экземпляром интерфейса, а не только наследует ли он класс."}

{"answer": "да", "пояснение": "С PHP 8.0 в интерфейсах можно определять методы с телом, то есть с реализацией по умолчанию, и их можно переопределить в классе."}

{"answer": "да", "пояснение": "В PHP абстрактный метод может иметь любую видимость (public, protected, private), поэтому protected допустим; при этом в наследнике видимость можно только расширять, а не сужать."}

{"answer": 3, "пояснение": "Метод Enum::cases() возвращает массив всех объявленных констант枚举, а их здесь три — A, B и C."}

{"answer": "да", "пояснение": "Трейты в PHP могут объявлять константы, свойства и методы, которые затем используются классом, использующим этот трейт."}

{"answer": "да", "пояснение": "В PHP 7+ интерфейsc Throwable является общим предком для классов Exception и Error, поэтому оба наследуют этот интерфейс."}

```json ⏎ {"answer": "нет", "пояснение": "TypeError наследуется от Error, а не от Exception, поэтому catch (Exception) его не перехватывает — оба имплементируют общий интерфейс Throwable."} ⏎ ```

{"answer": "нет", "пояснение": "Оператор @ подавляет только сообщения об ошибках (предупреждения, уведомления), но не исключении, которые обрабатываются через try/catch."}

{"answer": "DivisionByZeroError", "пояснение": "intdiv(5, 0) бросает DivisionByZeroError — исключение, расширяющее ArithmeticException, возникающее при делении на ноль в целом."}

{"answer": "нет", "пояснение": "Блок finally выполняется всегда — как при наличии пойманного исключения, так и при его отсутствии, и даже если исключение было непрехваченным и выбросилось из кода."}

{"answer": "нет", "пояснение": "Исключение из finally блокирует исходное значение (или исключение) из try-блока и переопределяет результат выполнения всей конструкции."}

{"answer": "да", "пояснение": "Объекты при приведении к bool всегда возвращают true, за исключением пустых объектов (без свойств), а у Exception есть свойства, поэтому результат — true."}

{"answer": "да", "пояснение": "Функции, зарегистрированные через register_shutdown_function(), действительно выполняются при завершении скрипта, включая случай вызова exit() или die()."}

```json ⏎ {"answer": "нет", "пояснение": "Оператор use лишь создаёт псевдоним для полностью определённого имени класса, но не включает файл — его загрузкой занимается автозагрузчик (например, Composer)."} ⏎ ```

{"answer": "function", "пояснение": "В PHP для импорта функции из пространства имён используется ключевое слово function, например: use Function\\Namespace\\fn; а для константы — const."}

{"answer": "Controller/Api/UserController.php", "пояснение": "По PSR-4 пространство имён App\\ мапится на src/, поэтому каждый разделитель пространства имён превращается в разделитель каталогов, а класс получает расширение .php."}

{"answer": "да", "пояснение": "Файл vendor/autoload.php подключает класс Autoloader из Composer, который регистрирует свои обработчики именно через spl_autoload_register()."}

{"answer": "да", "пояснение": "Магическая константа __NAMESPACE__ действительно содержит имя текущего пространства имён в виде строки."}

{"answer": "да", "пояснение": "В PHP неqualified-имя класса без ведущего \\ в новом объекте резолвится относительно текущего пространства имён, но для unqualified-имён происходит падение на глобальный корень, поэтому `new Foo()` из пространства имён `App` преобразуется в `\Foo`."}

```json ⏎ {"answer": "да", "пояснение": "По соглашению PSR-4 пространство имён App\\ маппится на директорию src/, а обратные слэши в имени класса App\\Model\\User заменяются на прямые, поэтому класс находится в src/Model/User.php."} ⏎ ```

{"answer": "нет", "пояснение": "Оператор use для импорта классов, пространств имён, констант и функций является оператором верхнего уровня и обрабатывается на этапе компиляции, поэтому его нельзя разместить внутри тела функции — он применяется ко всей области видимости пространства имён, а не отдельной функции."}

{"answer": "да", "пояснение": "В PHP массивы являются значениями, поэтому при присваивании одного массиву другой переменной создаётся его копия (с механикой copy-on-write), а не ссылка."}

{"answer": 2, "пояснение": "В PHP массивы копируются при присваивании (copy-on-write), поэтому изменение $b не влияет на $a, у которого два элемента."}

{"answer": "да", "пояснение": "По умолчанию в теле функции существует только локальная область видимости, поэтому глобальные переменные доступны лишь через global, $GLOBALS или передачу параметром."}

{"answer": "нет", "пояснение": "unset($GLOBALS['x']) удаляет глобальную переменную целиком, потому что $GLOBALS — это суперглобальный массив, ссылающийся на настоящие глобальные переменные, и он доступен из любой точки программы."}

{"answer": 6, "пояснение": "Поскольку параметр $x передаётся по ссылке ($&x), инкремент $x увеличивает исходную переменную $n с 5 до 6."}

{"answer": "нет", "пояснение": "foreach по значению итерирует по копии (снимку) массива, сделанной в начале прохода, поэтому любые изменения внутри цикла — как переприсваивание, так и добавление/удаление элементов — на текущий проход не влияют; чтобы видеть изменения, нужно итерировать по ссылке (foreach ($arr as &$v)."}

{"answer": "нет", "пояснение": "Статическое свойство принадлежит самому классу и共享 у всех экземпляров, поэтому изменения через один объект видны и в других."}

{"answer": "нет", "пояснение": "В PHP ключи массива могут быть только int или string, поэтому булев ключ true автоматически приводится к строке \"1\" и не сохраняется как bool."}

{"answer": "да", "пояснение": "С PHP 7.1 внутри генератора можно использовать return со значением, которое становится доступным через метод Generator::getReturn()."}

{"answer": "нет", "пояснение": "Генератор в PHP одноразовый: после полного исчерпания его нельзя перемотать через rewind(), так как это вызовет ValueError — повторная итерация невозможна."}

```json ⏎ {"answer": "нет", "пояснение": "В PHP нет конструкции yield from — это синтаксис Python; в PHP существует только оператор yield для создания генераторов."} ⏎ ```

{"answer": "Generator", "пояснение": "Функция с yield является генераторной, поэтому g() возвращает объект класса Generator, а get_class(name) возвращает строку с именем класса."}

{"answer": "3", "пояснение": "Генератор через yield from выдает 3 элемента (1, 2, 3), iterator_to_array превращает их в массив из 3 элементов, поэтому count вернет 3."}

{"answer": "нет", "пояснение": "SplStack реализует LIFO-структуру данных (стек), а не FIFO-очередь — элементы добавляются и извлекаются с конца стека."}

{"answer": "да", "пояснение": "ArrayIterator — это класс, который оборачивает массив и позволяет обходить его через интерфейс Iterator (и Countable, SeekableIterator)."}

{"answer": "нет", "пояснение": "ArrayObject implements IteratorAggregate и ArrayAccess, поэтому его можно перебирать через foreach."}

```json ⏎ {"answer": "да", "пояснение": "Функция password_hash() автоматически генерирует случайную соль и включает её в результирующую строку хеша, поэтому передавать её отдельно не требуется."} ⏎ ```

{"answer": "нет", "пояснение": "PASSWORD_DEFAULT в PHP 8 использует bcrypt (CRYPT_BLOWFISH), а не md5, так как md5 является устаревшим и небезопасным хешем."}

{"answer": "true", "пояснение": "password_verify проверяет совпадение пароля с хешем, встроенная случайная соль в хеше обеспечивает успешную проверку, поэтому возвращается true."}

```json ⏎ {"answer": "нет", "пояснение": "strip_tags() только удаляет HTML и PHP-теги из строки (защита от XSS), но не защищает от SQL-инъекций, для которых используются подготовленные запросы и параметизация."} ⏎ ```

{"answer": "да", "пояснение": "session_regenerate_id() меняет ID сессии, что предотвращает атаки fixation сессии при смене уровня доступа пользователя."}

{"answer": "php_sapi_name()", "пояснение": "Функция php_sapi_name() возвращает имя активного SAPI-модуля, например 'cli', 'fpm-fcgi' или 'apache2handler'."}

{"answer": "да", "пояснение": "session_destroy() уничтожает данные сессии на сервере, но cookie в браузере пользователя остаётся; для его удаления нужно отдельно вызвать setcookie() с прошлой датой."}

{"answer": "нет", "пояснение": "Массив $_SESSION доступен только после вызова session_start(), который инициализирует сессию и загружает её данные."}

{"answer": "8.2", "пояснение": "Функция array_find() была добавлена в PHP 8.2 как часть набора функций для работы с массивами, включая array_find, array_any и array_all."}

{"answer": "да", "пояснение": "Property hooks (инкапсулированные get/set прямо в объявлении свойства) действительно были добавлены в PHP 8.4."}

{"answer": "нет", "пояснение": "Асимметричная видимость (asymmetric visibility) появилась в PHP 8.2, а не в 8.4."}

{"answer": "8.2", "пояснение": "Атрибут #[\\NoDiscard] был добавлен в PHP 8.2 для предупреждения о том, что возвращаемое значение функции нельзя игнорировать."}

{"answer": "8.3", "пояснение": "Оператор конвейера |> появился в PHP 8.3, позволяя передавать значение слева последним аргументом в функцию справа для удобной цепочки вызовов."}

{"answer": "8.4", "пояснение": "Синтаксис clone($obj, ['x' => 1]) для передачи свойств при клонировании появился в PHP 8.4."}

{"answer": "PHP 8.0", "пояснение": "Функции array_first() и array_last() появились в PHP 8.0, позволяя получить первый и последний элемент массива соответственно."}

{"answer": "8.4", "пояснение": "RFC «Partially Applied Functions» (включая версию v2) был принят и добавлен в PHP 8.4, что позволяет частично применять функции через синтаксис $fn(...)."}

{"answer": "8.5", "пояснение": "RFC clamp_v2 (функция clamp()) был принят и реализован в PHP 8.5 для ограничения числовых и строковых значений заданным диапазоном."}

{"answer": "да", "пояснение": "RFC Context Managers v2 был принят в PHP до 07.11.2026, что позволило использовать конструкции с автоматически вызываемыми методами close (например, через keyword using)."}

{"answer": "нет", "пояснение": "Такого конкретного RFC под названием «Bound-Erased Generic Types» не существует, и это выдуманное название/деталь, а не реальный документ."}

{"answer": "да", "пояснение": "RFC о включении ZTS по умолчанию (в частности для Windows в PHP 8.4) был принят, поэтому к ноябрю 2026 года такая возможность уже реализована."}

{"answer": "да", "пояснение": "В PHP 8.5 так и не были добавлены дженерики (параметризованные типы) — эта функция обсуждалась, но так и не реализована."}

{"answer": "да", "пояснение": "Согласно годовому циклу релизов PHP (8.5 вышла в ноябре 2025), на 07.11.2026 стабильной версией остаётся 8.5, а 8.6 запланирована на ноябрь 2026."}

{"answer": "да", "пояснение": "Ветка PHP 6 (с поддержкой Юникода) была отменена, и после PHP 5.6 сразу вышел PHP 7.0 в 2015 году."}

{"answer": "нет", "пояснение": "RFC с атрибутом #[\Deprecated] не был принят: обсуждение вызвало разногласия, и идея добавления атрибута депрекации в ядро в итоге не прошла."}

{"answer": "да", "пояснение": "Правило зависимостей в чистых и луковичных архитектурах действительно предписывает, что внутренние слои не зависят от внешних, а все зависимости направлены от периферии к центру."}

```json ⏎ {"answer": "да", "пояснение": "Сущности домена в соответствии с принципами чистой архитектуры и DDD должны оставаться чистым PHP-кодом, зависящим только от языка и стандартной библиотеки, чтобы оставаться фреймворко-независимыми и легко тестируемыми."} ⏎ ```

{"answer": "нет", "пояснение": "Контроллеры и Twig-шаблоны относятся к презентационному (представительскому) слою, а не к бизнес-логике; бизнес-логика живёт в доменном/прикладном слое, и тот факт, что они вызывают use cases, не делает их частью бизнес-логики."}

{"answer": "Сущности предметной области (domain-сущности)", "пояснение": "В самом центре луковичной архитектуры находятся доменные сущности, содержащие бизнес-правила и данные, не зависящие от внешних факторов."}

{"answer": "да", "пояснение": "deptrac — это статический анализатор, который проверяет правила архитектурных слоёв и ругается на запрещённые вызовы зависимостей."}

{"answer": "нет", "пояснение": "Use-кейсы (акторы) должны оставаться фреймворк-независимыми: они принимают примитивы или доменные данные входа (DTO/входные порты), но не HTTP-запросы или EntityManager, так как это свяжет бизнес-логику с уровнем инфраструктуры и нарушит разделение слоёв."}

{"answer": "Репозиторий", "пояснение": "Репозиторий — это паттерн, инкапсулирующий доступ к коллекции сущностей/агрегатов и скрывающий логику хранения за единым интерфейсом."}

{"answer": "да", "пояснение": "В чистой архитектуре работа с БД — это детали во внешнем слое, а домен и use cases зависят от абстракций (интерфейсов репозиториев), поэтому замена СУБД затрагивает только адаптеры данных."}

{"answer": "нет", "пояснение": "В DDD агрегат — это доменная концепция, объединяющая сущности и объекты значений как единую единицу согласованности, а не то же самое, что таблица базы данных."}

{"answer": "да", "пояснение": "В доменно-ориентированном дизайне Value Object действительно immutabellen и определяется (и сравнивается) своими атрибутами, а не уникальным идентификатором, в отличие от Entity."}

{"answer": "Aggregate root (корень агрегата)", "пояснение": "В DDD корень агрегата — это единственный объект-точка входа, через которую клиент может получать доступ к агрегату и изменять его состояние."}

{"answer": "да", "пояснение": "В DDD репозиторий моделирует множество агрегатов, и доступ к сущностям агрегата осуществляется только через корень aggregate, поэтому репозиторий объявляется для агрегата, а не для каждой сущности отдельно."}

{"answer": "да", "пояснение": "Согласно методологии DDD (Eric Evans), ubiquitous language — это единый словарь и модель, которые совместно разрабатываются разработчиками и предметными экспертами для единообразного описания домена."}

{"answer": "Метатеория", "пояснение": "Это метатеоретическая граница: внутри неё модель вместе с её языком образует единый объект исследования, а за её пределами тот же язык и понятия трактуются другими моделями."}

{"answer": "нет", "пояснение": "Анемичная модель считается антипаттерном в DDD, поскольку Эрик Эванс рекомендует богатые доменные модели, где объекты инкапсулируют и данные, и логику, а не только геттеры/сеттеры."}

{"answer": "да", "пояснение": "Ограниченный контекст задаёт границы применимости модели, поэтому одно и то же понятие действительно может быть представлено разными классами в разных контекстах."}

{"answer": "да", "пояснение": "По умолчанию контейнер Symfony инстанциирует сервис лишь при первом обращении к нему через get() и кэширует полученный объект для последующих запросов."}

{"answer": "debug:router", "пояснение": "Команда `debug:router` выводит все зарегистрированные маршруты Symfony с их деталями — именем, методом и путем."}

{"answer": "нет", "пояснение": "Autowiring автоматически связывает зависимости на основе типов в сигнатурах методов и конструкторов, поэтому большинство сервисов не нужно перечислять вручную в services.yaml."}

```json ⏎ {"answer": "да", "пояснение": "Twig компилирует шаблоны в оптимизированный PHP-код и сохраняет кэшированные классы на диск, что позволяет переиспользовать их между запросами."} ⏎ ```

{"answer": "да", "пояснение": "В режиме разработки Symfony кеширует собранный контейнер и пересобирает его только при изменении отслеживаемых файлов (конфигурации, шаблонов и т.п.), а не на каждом запросе."}

{"answer": "APP_ENV", "пояснение": "В Symfony переменная APP_ENV определяет активное окружение (dev, prod, test), выбирая соответствующую конфигурацию и буферизацию."}

{"answer": "нет", "пояснение": "Метод-контроллер в Symfony должен быть public, так как фреймворк вызывает его через reflection извне класса, а private-методы недоступны для такого вызова."}

{"answer": "нет", "пояснение": "Приоритет обработки события определяется только числовым параметром priority, а не тем, является ли обработчик подписчиком или обычным слушателем — сами по себе EventSubscriber не имеют автоматического приоритета над listeners."}

{"answer": "да", "пояснение": "Система guard была устаревшей и удалена в Symfony 6.0, на смену которой пришла система аутентификации на основе AuthenticatorInterface."}

{"answer": "[#[Secure]]", "пояснение": "Атрибут #[Secure] (Symfony 6.3+) проверяет аутентификацию и роль прямо на методе контроллера и возвращает 403, если у пользователя нет нужной роли."}

{"answer": "да", "пояснение": "Voters — это механизм системы безопасности Symfony, который позволяет проверять права доступа к конкретному объекту или ресурсу через вызов isGranted()."}

{"answer": "да", "пояснение": "В Symfony 7 аннотационный загрузчик Validation\\Mapping\\Loader\\AnnotationLoader удалён, поэтому ограничения валидации объявляются только PHP-атрибутами, а доктриновые доктбл-аннотации больше не поддерживаются."}

{"answer": "нет", "пояснение": "CSRF-защита в Symfony по умолчанию отключена — её нужно явно включить, добавив поле `_csrf_token` в форму и настроив параметры csrf (csrf_after_name, csrf_provider и т.п.)."}

{"answer": "да", "пояснение": "Серверная валидация в Symfony всегда выполняется независимо от клиентской проверки HTML5, так как её можно обойти, и именно она обеспечивает безопасность данных."}

{"answer": "make:form", "пояснение": "Команда `make:form` из Symfony Maker Bundle генерирует класс FormType."}

{"answer": "нет", "пояснение": "Symfony не хранит пароли в сессии — в сессии сохраняется только идентификатор пользователя (обычно его UID), а пароли должны храниться в виде надёжного хэша, а не в открытом виде."}

{"answer": "да", "пояснение": "В Symfony конфигурация бандлов действительно размещается в config/packages, обычно по одному файлу на бандл (например, framework.yaml, doctrine.yaml)."}

{"answer": "да", "пояснение": "Это распространённая практика: в репозиторий коммитится .env с типовыми dev-настройками как шаблон, а реальные секреты хранятся в отдельном некоммитимом .env.local."}

{"answer": "debug:container", "пояснение": "Команда `debug:container` (в старых версиях — `container:debug`) выводит список всех зарегистрированных сервисов контейнера Symfony и их алиасов."}

{"answer": "нет", "пояснение": "Скомпилированный контейнер Symfony заморочен (frozen), поэтому setParameter() вызывает LogicException — параметры задаются на этапе компиляции, а не меняются в рантайме из контроллера."}

{"answer": "нет", "пояснение": "По умолчанию в Symfony сервисы приватны (private: true), а публичными их нужно делать явно, так как приватность улучшает оптимизацию контейнера и диагностику."}

{"answer": "нет", "пояснение": "Бандлы могут работать с настройками по умолчанию без файла в config/packages, поэтому конфигурация не обязательна для каждого бандла."}

{"answer": "да", "пояснение": "В Symfony для подстановки значений переменных окружения в файлах конфигурации (в том числе services.yaml) действительно используется синтаксис %env(VAR)%."}

{"answer": "APP_DEBUG", "пояснение": "В Symfony режим отладки управляется переменной окружения APP_DEBUG, которая влияет на работу профайлера и отладку Twig."}

{"answer": "нет", "пояснение": "В Symfony Messenger один тип сообщения может обрабатываться несколькими обработчиками, которые настраиваются в карте сообщений (message bus mapping)."}

{"answer": "нет", "пояснение": "Sync-транспорт отправляет сообщения непосредственно (синхронно), без постановки в очередь и обработки воркером, в отличие от async, который использует очередь и воркера."}

{"answer": "bin/console messenger:consume", "пояснение": "Именно эта команда запускает воркер, который слушает транспорт и обрабатывает сообщения из очереди (в новых версиях используется `messenger:consume:stopped` для обработки ограниченного числа сообщений)."}

{"answer": "да", "пояснение": "В Symfony Messenger стратегия повторных попыток (retry_strategy) действительно настраивается на уровне каждого транспорта, что позволяет задавать максимальное число попыток, задержку и экспоненциальный рост времени ожидания отдельно для каждого транспорта."}

{"answer": "нет", "пояснение": "По умолчанию Symfony Messenger сериализует сообщения нативной PHP-сериализацией (PhpSerializer), а не JSON."}

{"answer": "да", "пояснение": "В Symfony 7.1 в Messenger добавлен планировщик, который по cron-расписанию порождает сообщения и отправляет их через шину Messenger."}

```json ⏎ { ⏎   "answer": "doctrine", ⏎   "пояснение": "В Symfony 6.2 добавлен встроенный транспорт messenger, который хранит сообщения в таблицах БД через Doctrine ORM, а DSN-префикс для него — 'doctrine'." ⏎ } ⏎ ```

{"answer": "да", "пояснение": "Пайплайн Messenger в Lanai поддерживает регистрацию собственных middleware, которые можно встроить до или после встроенных."}

{"answer": "нет", "пояснение": "LTS-релизы Symfony выходят ежегодно (обычно в мае или ноябре), а не каждые шесть месяцев."}

{"answer": "8.4", "пояснение": "Symfony 8, планируемый к выпуску в ноябре 2026 года, требует PHP версии 8.4 или выше."}

{"answer": "нет", "пояснение": "В Symfony 7.0 поддержка аннотаций (annotations) была полностью удалена, используется только PHP 8 Attributes."}

{"answer": "да", "пояснение": "AssetMapper в Symfony управляет ассетами CSS/JS через файл importmap.php без необходимости в Node.js и webpack."}

{"answer": "нет", "пояснение": "Symfony 6.4 — это LTS-релиз (Long Term Support), поддерживаемый 5 лет: 2 года исправления ошибок и 3 года исправления уязвимостей, так как чётные минорные версии Symfony являются долгосрочно поддерживаемыми."}

```json ⏎ {"answer": "нет", "пояснение": "По политике Symfony устаревший код живёт 2 минорные версии после деприкейса, а затем удаляется именно в мажорном релизе."} ⏎ ```

{"answer": "да", "пояснение": "Да, каждый мажорный релиз Symfony сопровождается файлом UPGRADE с описанием обратных и прямых изменений для корректного перехода на новую версию."}

{"answer": "Symfony AssetMapper (symfony/importmap)", "пояснение": "Этот инструмент управляет JS/CSS-ассетами через importmap и позволяет обходиться без node и webpack."}

{"answer": "нет", "пояснение": "Symfony 8.2 выйдет лишь в мае 2027 года, поэтому к 07.11.2026 её ещё не существует."}

{"answer": "нет", "пояснение": "Symfony 8.1 запланирована на ноябрь 2026, тогда как Symfony 8.2 выйдет в мае 2027 года."}

{"answer": "8.2", "пояснение": "После релизов 8.0 (LTS, май 2026) и 8.1 (ноябрь 2026) следующей точной версией мажорной ветки 8 станет 8.2, запланированная на май 2027 года."}

{"answer": "нет", "пояснение": "Версия 8.2 — это минорный релиз (число после точки), содержащий обратно совместимые улучшения, тогда как мажорный релиз с ломающими изменениями — это 8.0."}

{"answer": "да", "пояснение": "В PHP обратная совместимость гарантируется внутри мажорной ветки 8.x: обновления версий (8.1 → 8.2 → 8.3) не должны ломать существующий код, а обратно несовместимые изменения вносятся только при смене мажорной версии (например, 8 → 9)."}

{"answer": "8.4", "пояснение": "В модели версии Symfony LTS-выпуски — это x.0 и x.4, поэтому последней минорной версией ветки 8.x перед 9.0 является 8.4."}

{"answer": "нет", "пояснение": "Symfony 8.0 будет требовать PHP 8.4, а минорные версии (8.1, 8.2) наследуют это требование, поэтому PHP 8.5 не нужен."}

{"answer": "да", "пояснение": "По политике deprecation Symfony устаревший код, добавленный в крупной версии 8.x, удаляется только в следующей крупной версии 9.0, поэтому ранее 9.0 он не исчезнет."}

{"answer": "нет", "пояснение": "В Twig внутри {{ }} можно использовать только синтаксис Twig (переменные, фильтры, вызовы методов объектов), но не произвольный PHP-код — это сделано для безопасности и разделения логики и разметки."}

{"answer": "да", "пояснение": "Twig по умолчанию включённый autoescape экранирует переменные в зависимости от контекста (html, js, css и т.д.)."}

{"answer": "да", "пояснение": "Фильтр |e в Twig применяет HTML-экранирование по умолчанию, заменяя специальные символы (&, <, >, \", ') на HTML-сущности, что делает вывод безопасным."}

{"answer": "number_format", "пояснение": "В twig/intl-extra именно фильтр number_format форматирует число с учётом локали через IntlNumberFormatter."}

{"answer": "да", "пояснение": "Фильтр |raw в Twig помечает значение как безопасное, отключая для него автоэкранирование."}

{"answer": "да", "пояснение": " Twig действительно использует {{ }} для вывода значений выражений, а {% } — для выполнения тегов, таких как условия, циклы и set."}

{"answer": "нет", "пояснение": "В Twig можно объявлять переменные внутри шаблона с помощью тега {% set %}, хотя значения по умолчанию действительно обычно передаются из контроллера."}

```json ⏎ {"answer": "dump", "пояснение": "Функция Twig dump() выводит отладочную информацию о переменной, показывая её структуру (массивы, объекты) через var_export или print_r."} ⏎ ```

{"answer": "да", "пояснение": "Bootstrap — это библиотека готовых CSS и JS-компонентов интерфейса, а не фреймворк для создания SPA, такие как React, Vue или Angular."}

{"answer": "container", "пояснение": "Класс .container задаёт адаптивный контейнер с фиксированной максимальной шириной, которая меняется в зависимости от брейкпоинтов Bootstrap."}

{"answer": "нет", "пояснение": "Сетка Bootstrap делит строку на 12 колонок, а не на 16."}

{"answer": "да", "пояснение": "В Bootstrap 5 пять именованных брейкпоинтов с инфиксом в классах: sm, md, lg, xl, xxl (кроме xs, у которого инфикса нет)."}

{"answer": "да", "пояснение": "В Bootstrap 5 утилиты отступов вычисляются как множитель $spacer (например, .mt-3 = $spacer × 1, .mt-1 = $spacer × 0.25), поэтому число действительно является множителем переменной $spacer."}

{"answer": "data-bs-toggle", "пояснение": "Bootstrap 5 использует префикс `data-bs-` (из-за множественных экземпляров библиотеки), и именно `data-bs-toggle="dropdown"` активирует интерактивный компонент на элементе."}

{"answer": "да", "пояснение": "В Bootstrap 5 удалена зависимость от jQuery, и все компоненты (модальные окна, карусели, аккордеоны и т. д.) работают на чистом vanilla JavaScript."}

{"answer": "нет", "пояснение": "В Bootstrap 5 тёмную тему включают атрибутом data-bs-theme=\"dark\" на корневом элементе, а не классом .dark."}

{"answer": "нет", "пояснение": "Doctrine ORM не создаёт таблицы автоматически в рантайме — это делается вручную через консольную команду `doctrine:schema:create`."}

{"answer": "persist", "пояснение": "Метод persist() помечает новый объект как управляемый и добавляет его в очередь на вставку, но SQL-запрос выполняется только после вызова flush()."}

{"answer": "нет", "пояснение": "В Doctrine ORM 3 метод EntityManager::merge() был удалён как устаревший (вместо него рекомендуется использовать refresh() или копирование данных между объектами)."}

{"answer": "да", "пояснение": "DQL (Doctrine Query Language) действительно строится в терминах сущностей и их свойств/полей, а не таблиц и столбцов базы данных, что позволяет писать ориентированные на объекты запросы."}

{"answer": "null", "пояснение": "Метод find() в Doctrine-репозитории возвращает null, если сущность с заданным идентификатором не найдена."}

{"answer": "нет", "пояснение": "По умолчанию Doctrine не вызывает flush() автоматически — нужно делать это вручную, хотя есть опция orm.auto_flush, которая включает авто-флуш."}

{"answer": "да", "пояснение": "У Doctrine Unit of Work по умолчанию использует режим отслеживания изменений (LAUNCH), поэтому для уже управляемой сущности достаточно изменить свойство и вызвать flush() — persist() для неё не нужен, так как сущность уже известна Unit of Work."}

{"answer": "нет", "пояснение": "Метод remove() только планирует удаление объекта в UnitOfWork, а реальный SQL DELETE выполняется только во время flush()."}

{"answer": "нет", "пояснение": "Преимущество MVCC как раз в том, что читатели не блокируют писателей и писатели не блокируют читателей — они работают с различными снимками данных одновременно."}

{"answer": "EXPLAIN", "пояснение": "Команда EXPLAIN показывает план выполнения запроса (например, EXPLAIN SELECT ...), не выполняя сам запрос, в отличие от EXPLAIN ANALYZE, который его выполняет."}

{"answer": "нет", "пояснение": "SERIAL — это устаревший механизм, создавающий последовательность и значение по умолчанию, а GENERATED AS IDENTITY — новый стандартный механизм с расширенным контролем (настройки identity-колонки, приоритет при оверрайд), поэтому они не одинаковы."}

{"answer": "нет", "пояснение": "В PostgreSQL значения NULL считаются разными, поэтому ограничение UNIQUE допускает любое количество NULL-значений в столбце, а не только одно."}

{"answer": "STRING_AGG", "пояснение": "STRING_AGG — это агрегатная функция PostgreSQL, которая объединяет строковые значения в одну строку с указанным разделителем."}

```json ⏎ {"answer": "нет", "пояснение": "Обычный VACUUM только освобождает место «мёртвых» кортежей для повторного использования внутри таблицы, но не отдаёт его операционной системе; это делает VACUUM FULL."} ⏎ ```

{"answer": "PARTITION BY", "пояснение": "В определении оконной функции ключевое слово PARTITION BY разбивает строки на группы (окна), внутри которых вычисляется оконная функция."}

{"answer": "нет", "пояснение": "READ COMMITTED защищает только от грязного чтения, а от неповторяющегося чтения защищает уровень REPEATABLE READ."}

{"answer": "да", "пояснение": "По умолчанию в PostgreSQL включён режим autocommit, при котором каждый отдельный SQL-оператор автоматически выполняется в собственной неявной транзакции и сразу коммитится."}

{"answer": "COMMIT", "пояснение": "Команда COMMIT фиксирует и сохраняет все изменения, внесённые в транзакцию, завершая её."}

{"answer": "да", "пояснение": "Индекс помогает быстро находить строки не только в SELECT, но и в UPDATE и DELETE, когда в WHERE есть поиск по индексированному столбцу, что позволяет избежать полного сканирования таблицы."}

{"answer": "да", "пояснение": "SAVEPOINT в PostgreSQL создаёт именованную точку внутри транзакции, к которой можно выполнить ROLLBACK TO для отчасти операторов без завершения транзакции целиком."}

{"answer": "нет", "пояснение": "EXPLAIN ANALYZE не только показывает план запроса, но и реально выполняет его, выводя фактическое время выполнения и другие статистические данные, в отличие от простого EXPLAIN."}

{"answer": "pgvector", "пояснение": "Расширение pgvector добавляет в PostgreSQL типы данных для векторов и поддержку индексов (IVFFLAT, HNSW) для приближённого поиска по эмбеддингам."}

```json ⏎ {"answer": "да", "пояснение": "Частичный индекс в PostgreSQL создаётся только для строк, удовлетворяющих условию в WHERE, что уменьшает его размер и ускоряет запросы с этим фильтром."} ⏎ ```

{"answer": "нет", "пояснение": "В PostgreSQL уровень SERIALIZABLE реализован не блокировкой строк, а через Serializable Snapshot Isolation (SSI) с обнаружением конфликтов сериализации и прерыванием транзакции при их выявлении."}

{"answer": "да", "пояснение": "Код состояния 201 Created возвращается сервером именно когда запрос привёл к созданию нового ресурса."}

{"answer": "204", "пояснение": "204 No Content означает, что запрос выполнен успешно, но тело ответа пусто, что типично для операции DELETE."}

{"answer": "да", "пояснение": "DELETE действительно является идемпотентным по спецификации HTTP, поскольку повторные запросы к одному и тому же ресурсу не изменяют результат — после удаления последующие запросы просто фиксируют отсутствие ресурса (часто с 404)."}

{"answer": "нет", "пояснение": "Заголовок Access-Control-Allow-Origin отправляет сервер в ответе, а не клиент, указывая, какие origin разрешено получать доступ к ресурсу."}

{"answer": "да", "пояснение": "Код 429 Too Many Requests действительно возвращается сервером, когда клиент превышил установленный лимит запросов при ограничении частоты обращений (rate limiting)."}

{"answer": "нет", "пояснение": "4xx — это ошибки клиента, а 5xx — ошибки на стороне сервера, то есть в утверждении значения перепутаны местами."}

{"answer": "Content-Type", "пояснение": "Заголовок Content-Type указывает MIME-тип тела HTTP-запроса или ответа."}

{"answer": "да", "пояснение": "RFC 5789 прямо указывает, что PATCH не обязан быть идемпотентным, в отличие от PUT, который должен сохранять результат при многократном повторении."}

{"answer": "нет", "пояснение": "Сравнение хешей оператором == уязвимо к тайминг-атакам, поэтому для безопасного сравнения нужно использовать hash_equals() или password_verify()."}

{"answer": "да", "пояснение": "Это корректный механизм защиты: CSRF-токен генерируется сервером, привязывается к сессии и проверяется на стороне сервера при изменяющих состояние (unsafe) запросах, что не позволяет атакующему подделать его из-за отсутствия доступа к сессии жертвы."}

{"answer": "Content-Security-Policy", "пояснение": "Политика CSP передаётся в HTTP-заголовке Content-Security-Policy, который указывает браузеру, какие источники контента разрешены к загрузке."}

{"answer": "нет", "пояснение": "OAuth 2.0 — это фреймворк авторизации, а не аутентификации: access-токен предоставляет доступ к ресурсам, но сам по себе не идентифицирует пользователя; за определение личности отвечает OpenID Connect (ID-токен)."}

{"answer": "нет", "пояснение": "XSS — это уязвимость на стороне вывода, поэтому защита обеспечивается экранированием (кодированием) данных при отображении с учётом контекста, а не только валидацией ввода перед сохранением в базу."}

{"answer": "authorization_code (code)", "пояснение": "В authorization code flow ресурсный сервер возвращает параметр code в redirect_uri, который затем обменивается на access-токен."}

{"answer": "да", "пояснение": "Refresh-токен действительно имеет более длительный срок жизни, чем access-токен, и позволяет получить новый access-токен без повторного входа пользователя."}

{"answer": "нет", "пояснение": "Соль не обязана быть секретной — обычно она хранится вместе с хешем открыто; её цель в том, чтобы предотвратить атаки радужными таблицами и сделать хеши одинаковых паролей разными, а не в обеспечении секретности."}

{"answer": "нет", "пояснение": "PHPUnit распознаёт тестовые методы (начинающиеся с \"test\") в классах, которые наследуются от PHPUnit\Framework TestCase, поэтому наследование необходимо."}

```json ⏎ {"answer": "нет", "пояснение": "Метод setUp() вызывается перед КАЖДЫМ тестом, а не один раз; один раз перед всеми тестами класса срабатывает статический метод setUpBeforeClass()."} ⏎ ```

{"answer": "нет", "пояснение": "Data-провайдер как раз позволяет прогнать тест с несколькими наборами аргументов, каждый из которого возвращает метод-провайдер."}

{"answer": "expectException", "пояснение": "Метод expectException() в PHPUnit объявляет ожидание исключения определённого класса."}

{"answer": "нет", "пояснение": "Всё наоборот: мок (mock) заранее программируется с ожиданиями и проверяет, какие методы были вызваны, а стаб (stub) лишь подставляет (возвращает) заранее подготовленные данные без проверки вызовов."}

```json ⏎ {"answer": "да", "пояснение": "В PHPUnit 10 метаданные-аннотации (@dataProvider) признаны устаревшими, и вместо них рекомендуется использовать PHP-атрибут #[DataProvider]."} ⏎ ```

{"answer": "нет", "пояснение": "В PHPUnit можно объявить зависимость теста от другого с помощью аннотации @depends."}

{"answer": "--order-by=random", "пояснение": "Опция --order-by=random в PHPUnit 10+ выполняет тесты в случайном порядке, а в более старых версиях использовалась опция --random-order."}

{"answer": "3-3", "пояснение": "intdiv делит нацело с округлением к нулю: intdiv(7,2)=3, intdiv(-7,2)=-3, а через точку строки конкатенируются в \"3-3\"."}

{"answer": "-9", "пояснение": "В PHP оператор возведения в степень ** имеет более высокий приоритет, чем унарный минус, поэтому код вычисляется как -(3 ** 2) = -9."}

{"answer": "true", "пояснение": "Обе строки трактуются как числа: '1e1' равно 10, и '10' тоже равно 10, поэтому нестрогое сравнение '10' == '10' истинно."}

{"answer": "zero", "пояснение": "Switch использует нестрогое сравнение (==): строка 'a' при сравнении с числом 0 конвертируется в число, нечисловая строка становится 0, поэтому 0 == 0 истинно и срабатывает case 0."}

{"answer": "2c", "пояснение": "strtr с массивом заменяет подстроки, начиная с самого длинного совпадения ключа, поэтому 'ab' заменяется на '2', а 'c' остаётся без изменений."}

{"answer": "[]", "пояснение": "Отрицательный сдвиг -10 выходит за пределы строки из 5 символов, поэтому substr возвращает пустую строку, и на экран выводится '[]'."}

```json ⏎ {"answer": "k,n,m", "пояснение": "Оператор плюс для массивов — это объединение, где значения левого массива имеют приоритет, поэтому 'k' берётся из $a, 'n' из $a, а 'm' добавляется из $b, и ключи в таком порядке преобразуются через implode."} ⏎ ```

{"answer": "yxz", "пояснение": "usort сортирует по третьему элементу (2,1,2 → y,x,z), затем array_column берёт второй элемент каждого подмассива и implode склеивает их в строку \"yxz\"."}

{"answer": "4", "пояснение": "При распаковке ассоциативного массива ключи 'a' и 'b' сопоставляются с параметрами функции по именам, поэтому $a=5, $b=1 и результат 5-1=4."}

{"answer": "3", "пояснение": "Оператор \(...\) создаёт first-class callable, замыкание удерживает ссылку на объект, поэтому после \(\\$p = null\\) объект не уничтожается, и вызов \(\\$f()\\) возвращает 3."}

{"answer": "B", "пояснение": "static::class использует позднее связывание, поэтому возвращается имя класса реального экземпляра — B, а не A.")

{"answer": "10", "пояснение": "В PHP 8.4+ добавлены хуки свойств, поэтому сеттер умножает присвоенное значение на 2 (5*2=10), а геттер по умолчанию возвращает хранимое значение 10."}

{"answer": "BA", "пояснение": "Конфликт методов f разрешён в пользу TB::f (insteadof TA), поэтому f() возвращает 'B', аTA::f через алиас g возвращает 'A', в результате конкатенация 'BA'}

{"answer": "0", "пояснение": "У каждого класса, использующего трейт, создаётся собственная независимая копия статического свойства $n, поэтому присвоение CX::$n = 1 не влияет на CY::$n, который остаётся равным 0."}

{"answer": "2", "пояснение": "Блок finally с оператором return переопределяет результат, возвращённый в try, поэтому функция вернёт 2."}

{"answer": "second", "пояснение": "Исключение из finally переопределяет исходное RuntimeException и распространяется дальше, где его ловит catch LogicException и выводит его сообщение 'second'."}

{"answer": "App\\Foo|Baz", "пояснение": "Baz::class использует алиас из пространства N и даёт App\\Foo, а \\Baz::class обратным слешом обращается к глобальному пространству имён и даёт просто Baz."}

{"answer": "yesyes", "пояснение": "class_exists('Foo') разрешается как Ns\\Foo (текущее пространство имён) — существует, а class_exists('Ns\\Foo') — полностью определённое имя, тоже существует, поэтому обе подстроки 'yes'."}

{"answer": "1,2,99", "пояснение": "После foreach переменная $v остаётся ссылкой на последний элемент массива ($a[2]), поэтому присваивание $v = 99 изменяет именно $a[2]."}

```json ⏎ {"answer": "3", "пояснение": "Статическая переменная $n привязана к телу метода A::inc, а B её не переопределяет, поэтому $n общая для обоих объектов и инкрементируется в трёх последовательных вызовах: 1, 2, 3."} ⏎ ```

{"answer": "11", "пояснение": "send(10) запускает генератор, присваивая $x значение 10, после чего функция возвращает 10+1=11, и getReturn() это и возвращает."}

{"answer": "1,2,ok", "пояснение": "yield from передает значения из inner (1 и 2), а затем в $r записывается возвращаемое inner значение 'ok', которое тоже выдается через yield, поэтому в итоге implode получает массив [1, 2, 'ok']."}

{"answer": "noyes", "пояснение": "password_needs_rehash сравнивает только алгоритм и параметры (cost) с теми, что зашифрованы в хеше: для cost=4 совпадение (no), а cost=5 отличается от зашифрованного cost=4 (yes)."}

{"answer": "strict-in", "пояснение": "E_ALL по-прежнему включает бит E_STRICT (2048), поэтому E_ALL & 2048 = 2048, что не равно 0, и выбор падает на 'strict-in'."}

{"answer": "mapped", "пояснение": "Symfony конвертирует параметр сервера HTTP_X_TOKEN в заголовок X-Token (префикс HTTP_ убирается, символы _ заменяются на -), поэтому get('X-Token') вернет 'abc'."}

{"answer": "BCA", "пояснение": "Слушатели вызываются в порядке убывания приоритета: B (10), C (5), A (по умолчанию 0), поэтому в $out будет записано последовательно B, C, A."}

{"answer": "same", "пояснение": "Первый find размещает сущность в карте идентичности (first-level cache) EntityManager, поэтому второй find по тому же ID возвращает тот же экземпляр из кэша."}

{"answer": "0", "пояснение": "persist(), а затем remove() до flush() отменяет отслеживание сущности в Unit of Work — Doctrine просто удаляет её из множителя изменений, и вставка не выполняется, поэтому таблица остаётся пустой."}

{"answer": "1", "пояснение": "COUNT(x) считает только не-NULL значения, и из двух строк ненулевым является только одно, поэтому результат равен 1."}

{"answer": "\"10,30,60\"", "пояснение": "Вложенный запрос вычисляет бегущую сумму x (10, 30, 60), а string_agg склеивает их через запятую по возрастанию id."}

{"answer": "M1M2", "пояснение": "Мидлвары в Symfony Messenger выполняются в порядке регистрации: M1 (внешний) выводит «M1» и передает управление, затем M2 выводит «M2»."}

{"answer": "11", "пояснение": "Оба обработчика ($d1 и $d2) зарегистрированы для сообщения Ping::class и вызываются при dispatch, увеличивая $n на 1 и на 10 соответственно, в результате получаем 11."}

{"answer": "1", "пояснение": "Первый INSERT вставляет значение 1, второй наталкивается на уникальный индекс и выполняется DO NOTHING, поэтому в таблице остаётся ровно одна строка."}

{"answer": "2", "пояснение": "Ограничение UNIQUE отложено (DEFERRABLE INITIALLY DEFERRED), поэтому проверка на уникальность выполняется только закоммитом транзакции, а не сразу при вставке, так что обе строки с a=1 успешно вставляются и count(*) = 2."}

{"answer": "6", "пояснение": "Фильтр test_sum — это регулярка, которая неанхорирована и совпадает с test_sum (3 теста из провайдера) и test_sum_abs (тоже 3 теста), поэтому выполняется 3+3=6 тестов, а test_other отфильтрован."}

{"answer": "2, 1", "пояснение": "Провайдер возвращает 2 набора данных (1 и -1), поэтому выполняется 2 теста, и только для -1 assertion упадёт."}

{"answer": "POST", "пояснение": "Флаг -d автоматически меняет метод запроса на POST и отправляет данные в формате application/x-www-form-urlencoded."}

{"answer": "GET", "пояснение": "Флаг -G заставляет curl отправлять запрос методом вне зависимости от -d, добавляя данные в строку запроса URL вместо тела запроса."}

{"answer": "invalid_client", "пояснение": "Согласно RFC 6749 (раздел 5.2), при аутентификации клиента с неизвестным client_id эндпоинт возвращает ошибку invalid_client, поскольку клиентская аутентификация не прошла, включая случай неизвестного идентификатора клиента."}

{"answer": "в фрагменте (в части после символа #)", "пояснение": "В implicit-потоке OAuth 2.0 (response_type=token) access_token передаётся в фрагменте URI-перенаправления после знака #, чтобы ток не попадал в запросы к серверу и не логировался в referer."}

{"answer": "6", "пояснение": "Фильтр default в Twig считает false пустым значением, поэтому false|default(2) вернёт 2, а 2 * 3 = 6."}

{"answer": "a3", "пояснение": "В Twig оператор + имеет более высокий приоритет, чем ~, поэтому выражение вычисляется как \"a\" ~ (1 + 2) = \"a3\"; исключение не возникает."}

{"answer": "0", "пояснение": "NotBlank проверяет конкретное значение, а не элементы массива; так как переданным значением является массив [''] (а не пустая строка), нарушений не возникает и count возвращает 0."}

{"answer": "Symfony\\Component\\Form\\Exception\\RuntimeException", "пояснение": "Вызов isValid() на форме, которая не была отправлена (не пройдена через submit()), вызывает RuntimeException «Forms can only be validated for submissions».", "note": ""}

{"answer": "same", "пояснение": "Публичный сервис кэшируется в контейнере, поэтому второй вызов get() вернёт тот же объект и spl_object_id совпадёт."}

{"answer": "hi Bob!", "пояснение": "Symfony резолвит вложенные параметры рекурсивно: %greeting% заменяется на «hi %name%», а %name% на «Bob», в итоге получается «hi Bob!»."}

{"answer": "960px", "пояснение": "В Bootstrap 5.3 breakpoint lg срабатывает при min-width: 992px, а max-width для .container в этом диапазоне составляет 960px."}

{"answer": "text-primary", "пояснение": "Оба класса имеют одинаковую специфичность, поэтому в каскаде побеждает тот, что идёт позже в атрибуте class — text-primary."}

{"answer": "2", "пояснение": "Class OrderService находится в слое Domain, который может зависеть только от Domain: зависимость от Application\PlaceOrder и Infrastructure\Db — два нарушения."}

{"answer": "3", "пояснение": "Класс принадлежит слою Domain, которому разрешено зависеть только от Domain, но он импортирует PlaceOrder (Application) и Db с Logger (Infrastructure) — каждое из трёх ссылок нарушает правило."}

{"answer": "10,15", "пояснение": "Объект $a имеет amount 10, add возвращает новый объект $c с amount 15, поэтому выводится «10,15»."}

{"answer": "1", "пояснение": "Метод remove бросает DomainException, потому что до вызова count элементов всего один, и unset не выполняется, поэтому count по-прежнему равен 1; при этом count($this->items) вызывает глобальную функцию для массива, а не метод класса."}

{"answer": "hi", "пояснение": "Выражение `new C()->hi()` создаёт объект и сразу вызывает метод hi(), который возвращает строку 'hi', а echo выводит её на экран; этот синтаксис доступен с PHP 5.4 и в 8.5 работает без изменений."}

{"answer": "yesno", "пояснение": "newLazyGhost создаёт инициализированный прокси-объект, поэтому первый isUninitializedLazyObject возвращает 'yes'; обращение к $o->v вызывает колбэк и инициализирует объект, из-за чего второй вызов вернёт 'no'."}

{"answer": "no", "пояснение": "Guard-аутентификация была удалена в Symfony 6.0, поэтому класс AbstractGuardAuthenticator на новых версиях отсутствует."}

{"answer": "noyes", "пояснение": "AnnotationClassLoader (основанный на Doctrine-аннотациях) был удалён в Symfony 7.0, поэтому на 8.1 его нет ('no'), а AttributeClassLoader присутствует ('yes')."}