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

{"answer": "no", "explanation": "Double-quoted strings undergo variable interpolation and escape-sequence parsing, while single-quoted strings are treated almost literally, so they are processed differently, not just at different speeds."}

{"answer": "yes", "explanation": "The null coalescing operator (??) follows isset() semantics and does not emit a warning when accessing undefined variables or array keys."}

{"answer": "ab", "explanation": "In PHP, echo accepts multiple comma-separated arguments and outputs them concatenated with no separator, so 'a' and 'b' print as 'ab'."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, print is a language construct that always returns the integer value 1, which allows it to be used within expressions."} ⏎ ```

{"answer": "no", "explanation": "The ?: (elvis) operator returns its left operand when it is truthy, not when it is falsy; it returns the right operand only when the left operand is falsy."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, the addition and subtraction operators have higher precedence than the concatenation operator, so 'a' . 1 + 2 evaluates as 'a' . (1 + 2) = 'a3', confirming concatenation has lower precedence."} ⏎ ```

{"answer": "false", "explanation": "The exponentiation operator `**` in PHP is right-associative, so `2 ** 3 ** 2` evaluates as `2 ** (3 ** 2)` = `2 ** 9` = 512, not 64."}

```json ⏎ {"answer": "sum: 5", "explanation": "In PHP, the + operator has higher precedence than ., so 'sum: ' . 2 + 3 is evaluated as 'sum: ' . (2 + 3) = 'sum: ' . 5 = 'sum: 5'."} ⏎ ```

{"answer": "no", "explanation": "In PHP, the strict comparison operator (===) requires arrays to have the same key/value pairs in the same order, so order matters and they are not equal if the order differs."}

{"answer": "no", "explanation": "`==` is a loose (non-strict) comparison and `0 == false` actually evaluates to `true` because `0` is coerced to `false` under loose comparison, so the statement is false on both counts."}

{"answer": "yes", "explanation": "In loose comparison, the string 'abc' is converted to the integer 0 (non-numeric strings evaluate to 0), so 'abc' == 0 becomes 0 == 0, which is true."}

```json ⏎ {"answer": "yes", "explanation": "Under PHP's loose comparison (==), null is treated as both 0 and '' when compared to numbers or strings, and equals false as well, so null == 0, null == '', and null == false are all true."} ⏎ ```

{"answer": 42, "explanation": "PHP casts a string to an integer by parsing the leading numeric portion, so '42abc' becomes 42 and the non-numeric suffix 'abc' is ignored."}

{"answer": 10, "explanation": "The + operator forces PHP to convert the string '5' to a number, so both operands are treated numerically and 5 + 5 evaluates to 10."}

{"answer": "no", "explanation": "When false is cast to a string in PHP, it becomes an empty string \"\", not \"0\"."}

{"answer": "yes", "explanation": "0.1 + 0.2 evaluates to 0.30000000000000004 due to floating-point precision, so the strict comparison === 0.3 returns false."}

{"answer": "no", "explanation": "strrev() reverses a string byte-by-byte, which corrupts multi-byte UTF-8 characters since it does not account for character boundaries."}

{"answer": "yes", "explanation": "str_contains() is a PHP 8.0 function that returns a boolean true when the substring 'world' is found within 'Hello world', so the statement is correct."}

{"answer": "false", "explanation": "str_pad() can pad on the left (STR_PAD_LEFT), right (STR_PAD_RIGHT), or both (STR_PAD_BOTH) sides based on the pad_type parameter."}

{"answer": "no", "explanation": "trim() by default removes spaces, tabs, newlines, carriage returns, NUL bytes, and vertical tabs, not just spaces."}

{"answer": "6", "explanation": "strlen counts bytes, not characters, so 'héllo' has 5 characters but 'é' takes 2 bytes in UTF-8, giving 1+2+1+1+1 = 6 bytes."}

{"answer": "def", "explanation": "In PHP, a negative offset counts from the end of the string, so -3 starts 3 characters from the end, returning 'def'."}

{"answer": "no", "explanation": "ucfirst() returns a new string with the first letter capitalized and does not modify the original string, since strings in PHP are immutable."}

{"answer": "yes", "explanation": "Heredoc (<<<) expands variables during parsing, while nowdoc (<<<'...') treats content as literal text and does not interpolate variables, similar to single-quoted strings."}

{"answer": "no", "explanation": "sort() reindexes the array with new sequential integer keys and does not preserve the original key-to-value associations; asort() and ksort() are the functions that preserve keys."}

{"answer": "yes", "explanation": "In PHP, string keys that represent valid integers (like '5') are automatically converted to integer keys when used in a standard array."}

{"answer": "no", "explanation": "in_array() uses loose comparison by default; strict comparison (===) requires passing true as the third argument."}

{"answer": "yes", "explanation": "Without a callback, array_filter() keeps elements for which the value is not falsy, effectively removing empty/falsy values like false, null, 0, \"0\", 0.0, \"\", and empty arrays."}

```json ⏎ {"answer": "no", "explanation": "By default, array_slice() reindexes numeric keys (keys reset to start from 0), unless the optional preserve_keys parameter is set to true."} ⏎ ```

{"answer": "[20, 30]", "explanation": "array_slice extracts a slice starting at offset 1 (element 20) with length 2, returning [20, 30]."}

{"answer": "2", "explanation": "The '+' union operator preserves the left array's values, adding only keys from the right array that don't already exist, so ['a'=>1] + ['a'=>9,'b'=>2] yields ['a'=>1,'b'=>2]."}

{"answer": "yes", "explanation": "PHP 8.1 extended the spread operator to work with string-keyed arrays, allowing both merging and override of string keys during array unpacking."}

{"answer": "yes", "explanation": "According to the PHP documentation, named arguments cannot be combined with argument unpacking using ...$args in a single function call."}

{"answer": "no", "explanation": "In PHP, an anonymous function (closure) cannot access outer scope variables unless they are explicitly imported using the use keyword, unlike JavaScript closures."}

{"answer": "3", "explanation": "func_num_args() returns the total number of arguments passed to the function regardless of the number of declared parameters, so f(1, 2, 3) returns 3."}

{"answer": "false", "explanation": "Arrow functions in PHP must have a single-expression body without curly braces and automatically return its result; curly-brace multi-statement bodies are only allowed in regular closures."}

{"answer": "no", "explanation": "In PHP, arrow functions implicitly capture outer variables by value, not by reference."}

{"answer": "yes", "explanation": "A static closure in PHP explicitly does not bind to the object instance, so $this is not captured or available inside it."}

{"answer": "5", "explanation": "Closures capture variables by value, so $f captures the value of $x (5) at the time the closure is created, not the later reassigned value of 7."}

```json ⏎ {"answer": "yes", "explanation": "In weak typing mode (without strict_types), PHP coerces the string \"5\" to the integer 5 for an int parameter, allowing the call to succeed."} ⏎ ```

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, allowing properties to be declared directly in the constructor parameter list with access modifiers like `private`."}

{"answer": "final", "explanation": "The final keyword, when applied to a method, prevents subclasses from overriding it."}

{"answer": "yes", "explanation": "A final method cannot be overridden by a subclass, as the final keyword prevents both method overriding and class inheritance."}

{"answer": "no", "explanation": "Private properties in PHP are only accessible within the class that defines them and cannot be accessed directly by subclasses."}

{"answer": "class@anonymous", "explanation": "get_class() on an anonymous class returns a name formatted as 'class@anonymous\\0<file path>:<line>', so the part before the NUL byte is 'class@anonymous'."}

{"answer": "yes", "explanation": "Private methods are not inherited and not part of the inheritance contract, so a child class can freely declare a same-named method with any visibility without conflicting with the parent's private method."}

{"answer": "no", "explanation": "__get() is triggered not only for non-existent properties but also when accessing inaccessible (protected or private) properties from outside the class scope."}

{"answer": "error", "explanation": "In PHP (8.1+), reassigning a readonly property after initialization throws an \\Error (specifically a compile-time 'Cannot modify readonly property' error), not an Exception."}

{"answer": "yes", "explanation": "Since PHP 7.1, interfaces can declare constant members that are implicitly public and static."}

{"answer": "instanceof", "explanation": "The instanceof operator in PHP checks whether an object is an instance of a given class or interface."}

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces are allowed to declare static methods, which cannot be overridden by implementing classes."}

{"answer": "no", "explanation": "The instanceof operator in PHP checks both class inheritance and whether an object implements an interface, so it does not ignore interfaces."}

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces can declare methods with a default implementation (a body), similar to how trait methods provide their own implementation."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, abstract methods can be declared with any visibility modifier (public, protected, or private), so an abstract method may indeed have protected visibility."} ⏎ ```

{"answer": "3", "explanation": "Foo::cases() is a static method that returns an array containing all defined enum cases, so with cases A, B, and C it returns 3 elements."}

{"answer": "yes", "explanation": "Traits in PHP can declare constants, methods, and properties, just like classes can."}

{"answer": "yes", "explanation": "In PHP 7+, Throwable is an interface that serves as the common ancestor of both Exception and Error, enabling catchable handling of all fatal and non-fatal errors."}

{"answer": "yes", "explanation": "TypeError extends ArithmeticError extends RuntimeException extends Exception, so it is caught by a catch (Exception $e) block."}

{"answer": "no", "explanation": "The @ operator only suppresses errors like warnings and notices, not exceptions, which are still thrown and must be caught with try/catch."}

{"answer": "ArithmeticError", "explanation": "In PHP, intdiv(5, 0) throws an ArithmeticError exception because dividing an integer by zero is an arithmetic error, unlike floating-point division which returns Infinity."}

```json ⏎ {"answer": "no", "explanation": "The finally block always executes regardless of whether an exception was thrown or caught, as it is designed for cleanup code that must run in all cases."} ⏎ ```

{"answer": "no", "explanation": "An exception thrown inside a finally block overrides/replaces any exception or value from the try block, so it does affect the result."}

```json ⏎ {"answer": "true", "explanation": "Casting an object to bool always yields true unless the class defines a __bool() magic method, which Exception does not."} ⏎ ```

{"answer": "yes", "explanation": "Functions registered via register_shutdown_function() are executed when the script terminates, including when exit() or die() is called, before the response is sent."}

{"answer": "no", "explanation": "The `use` statement only creates a namespace alias; it does not load the class file, which is loaded lazily via autoloading when the class is actually referenced."}

```json ⏎ {"answer": "const", "explanation": "In JavaScript ES modules, functions are imported using the `const` keyword (e.g., `const myFunction = require(...)`) whereas classes are imported using the `import` keyword (e.g., `import MyClass from '...'`)."} ⏎ ```

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps each namespace separator to a directory separator and the class name to a .php file, so App\\Controller\\Api\\UserController under the App\\ prefix maps to src/Controller/Api/UserController.php."}

{"answer": "yes", "explanation": "Composer's vendor/autoload.php file registers PSR-4, class map, and file autoloaders by calling spl_autoload_register()."}

{"answer": "yes", "explanation": "__NAMESPACE__ is a PHP magic constant that returns the name of the current namespace."}

```json ⏎ {"answer": "no", "explanation": "In PHP, an unqualified class name in a new statement is resolved relative to the current namespace, not the global root, so it becomes CurrentNamespace\\ClassName rather than \\ClassName."} ⏎ ```

{"answer": "yes", "explanation": "Under PSR-4, the 'App\\' namespace maps to src/, so App\\Model\\User resolves to the file src/Model/User.php."}

{"answer": "no", "explanation": "Namespace 'use' import statements must appear at the top level of a file, before any executable code, and cannot be placed inside a function body."}

{"answer": "yes", "explanation": "In PHP, arrays are value types that are copied on assignment (copy-on-write) rather than passed by reference."}

{"answer": "2", "explanation": "In PHP arrays are passed/copied by value, so `$b = $a` creates a separate copy, and appending to `$b` leaves `$a` unchanged with 2 elements."}

{"answer": "yes", "explanation": "In PHP, function scope is isolated, so global variables must be accessed via the global keyword, the $GLOBALS superglobal array, or by passing them as parameters."}

{"answer": "no", "explanation": "Because $GLOBALS is a superglobal array holding references to all global variables, unset($GLOBALS['x']) destroys the variable globally, not just within the current function's scope."}

```json ⏎ {"answer": "6", "explanation": "inc() takes its argument by reference, so $n is incremented from 5 to 6, which is then echoed."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "foreach operates on a copy (snapshot) of the array, so modifications made inside the loop are not visible during the same pass."} ⏎ ```

{"answer": "no", "explanation": "A static property belongs to the class itself rather than individual instances, so changes are shared and visible across all objects."}

{"answer": "no", "explanation": "In PHP, boolean array keys are automatically coerced to integers (true becomes 1, false becomes 0), so they are never stored as booleans."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "PHP generators allow a return statement with a value, which can be retrieved after exhaustion via the Generator::getReturn() method." ⏎ } ⏎ ```

{"answer": "no", "explanation": "PHP generators are single-use and cannot be rewound or re-traversed after consumption; calling rewind() on a fully consumed generator throws a TypeError."}

{"answer": "yes", "explanation": "In PHP, `yield from` delegates traversal to another generator, Traversable object, or array, propagating both the yielded values and the return value of the delegated iterable."}

{"answer": "Generator", "explanation": "A function containing a yield statement becomes a generator function, so calling g() returns a Generator object whose class name is 'Generator'."}

{"answer": "3", "explanation": "The generator yields exactly 3 elements (1, 2, 3), and iterator_to_array converts all of them into a keyed array, so count returns 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (last-in-first-out) stack, while a FIFO queue is implemented by SplQueue."}

{"answer": "yes", "explanation": "ArrayIterator is a PHP SPL class designed exactly to wrap an array and iterate over it using the Iterator interface (and its many subclasses)."}

{"answer": "no", "explanation": "ArrayObject implements the IteratorAggregate interface, which extends Traversable, so instances can indeed be traversed with foreach."}

{"answer": "yes", "explanation": "password_hash() automatically generates a cryptographically random salt and embeds it in the resulting hash string, so the caller does not need to supply one."}

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT uses bcrypt (currently), not the insecure md5 hashing algorithm."}

{"answer": "yes", "explanation": "password_hash generates a bcrypt hash of 'secret' and password_verify confirms that 'secret' matches that freshly generated hash, returning true."}

{"answer": "false", "explanation": "strip_tags() only removes HTML and PHP tags from a string and offers no protection against SQL injection, which requires parameterized queries or proper SQL escaping."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID, which is the recommended defense against session fixation attacks, particularly after authentication when privilege levels change."}

{"answer": "php_sapi_name()", "explanation": "The built-in php_sapi_name() function returns the name of the SAPI (Server Application Programming Interface) module that is handling the request, such as 'cli' for command-line or 'fpm-fcgi' for PHP-FPM."}

{"answer": "yes", "explanation": "session_destroy() only removes the server-side session data; the session cookie in the browser is not deleted unless explicitly removed via setcookie() with a past expiration date."}

{"answer": "no", "explanation": "The $_SESSION array is only populated after session_start() is called, which initializes the session and loads any stored session data."}

{"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3."}

{"answer": "yes", "explanation": "Property hooks (get/set logic directly in property declarations) were introduced in PHP 8.4."}

{"answer": "false", "explanation": "Asymmetric visibility for properties was introduced in PHP 8.1, not PHP 8.4."}

```json ⏎ {"answer": "8.2", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2 to allow marking return values that should not be discarded."} ⏎ ```

{"answer": "8.1", "explanation": "The pipe operator (|>) was introduced as an experimental feature in PHP 8.1."}

{"answer": "no", "explanation": "PHP has never had a clone($obj, ['x' => 1]) syntax; the clone construct is written as clone $obj (e.g. $a = clone $obj)."}

{"answer": "7.3", "explanation": "array_first() and array_last() were both introduced in PHP 7.3."}

{"answer": "8.5", "explanation": "The Partial Function Application v2 RFC, which introduced the `|>` pipe operator for partial application, was adopted for PHP 8.5."}

{"answer": "8.4", "explanation": "The clamp() function was implemented in PHP 8.4 via the clamp_v2 RFC, which limits a numeric value between a specified lower and upper bound."}

{"answer": "no", "explanation": "The PHP Context Managers RFC (the `using`/`context` construct) was voted on but not adopted, and no Context Managers v2 was merged into PHP as of that date."}

{"answer": "false", "explanation": "There is no real PHP RFC titled 'Bound-Erased Generic Types'—generics have never been officially proposed or declined under that name, so the claim is fabricated."}

{"answer": "no", "explanation": "The RFC to make ZTS the default build in PHP was proposed but never accepted, largely due to concerns about the performance overhead it introduces, so ZTS remains opt-in as of 2026."}

{"answer": "yes", "explanation": "As of PHP 8.5, generics/parameterized types have still not been implemented in the language, despite ongoing design discussions and proposals."}

```json ⏎ {"answer": "yes", "explanation": "PHP follows a roughly annual release cycle (8.4 GA was Nov 2024, 8.5 GA around Nov 2025), so as of November 7, 2026, PHP 8.5 would be the latest stable release with 8.6 not yet at GA."} ⏎ ```

{"answer": "yes", "explanation": "The PHP 6 branch, which aimed to add native Unicode/UTF-16 support, was abandoned after years of development, so PHP 7.0 was released directly after PHP 5.6 without ever shipping a PHP 6 release."}

{"answer": "yes", "explanation": "The RFC for the #[\\Deprecated] attribute was adopted and the feature was included in PHP 8.4."}

{"answer": "yes", "explanation": "In clean and onion architecture, the dependency rule requires that source code dependencies always point inward, so inner layers never know about outer layers."}

{"answer": "yes", "explanation": "In clean/domain-driven architecture, domain entities must remain framework-agnostic, depending only on the language and standard library so they stay decoupled from persistence layers like Doctrine and framework layers like Symfony."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation layer, not the business-logic layer, even though they invoke use cases which constitute the business-logic layer."}

{"answer": "The Domain layer (domain entities and business logic)", "explanation": "In onion architecture, layers wrap around a central core, with the domain layer containing the essential business entities and rules sitting at the very center, protected by the surrounding application, infrastructure, and adapter layers."}

```json ⏎ {"answer": "yes", "explanation": "Deptrac analyzes code dependencies between layers and fails the build when a forbidden dependency or call across a layer boundary is detected."} ⏎ ```

{"answer": "no", "explanation": "Use cases must receive plain data (DTOs/value objects) through input ports rather than infrastructure objects like HTTP requests or an EntityManager, otherwise they become coupled to the web and persistence layers and lose their testability and independence."}

{"answer": "Repository", "explanation": "A Repository provides a collection of aggregates/entities while abstracting/hiding the storage mechanism behind an interface, following the Repository design pattern from Domain-Driven Design."}

{"answer": "yes", "explanation": "In clean architecture, the inner layers define port interfaces and depend on abstractions, so a database swap only requires replacing the data-access adapter in the outer layer while the domain and use cases remain untouched."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of entities and value objects treated as a unit for data changes, which does not necessarily correspond to a single database table."}

{"answer": "yes", "explanation": "Value Objects are defined by their attributes rather than identity, and are typically immutable so that equality can be determined by comparing their field values."}

{"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the aggregate root is the single external entry point of an aggregate through which all changes must be made to maintain its integrity."}

```json ⏎ {"answer": "yes", "explanation": "In DDD, repositories are declared only for aggregate roots, because entities inside an aggregate are managed through their root rather than via separate repositories."} ⏎ ```

{"answer": "yes", "explanation": "In Domain-Driven Design, the ubiquitous language is precisely the shared language developed between developers and domain experts that models the domain consistently across all communication and code."}

{"answer": "The semantic boundary (Tarski's metalanguage/object-language distinction)", "explanation": "In model theory and Tarskian semantics, within a given model and its language the symbols have consistent interpretations, while crossing into other models reassigns the same expressions different meanings—a distinction Tarski formalized via the object-language/metalanguage boundary."}

```json ⏎ {"answer": "no", "explanation": "DDD actually recommends a rich domain model where entities encapsulate behavior and enforce invariants, whereas the anemic model (data with only getters/setters and logic in services) is widely considered an anti-pattern by Eric Evans and Martin Fowler."} ⏎ ```

{"answer": "yes", "explanation": "In Domain-Driven Design, a bounded context defines the boundaries within which a model applies, and the same concept can indeed be represented by different classes in different contexts due to differing requirements and language."}

{"answer": "yes", "explanation": "Symfony's DI container instantiates services on-demand (lazily) when they are first requested rather than creating them all up front."}

{"answer": "debug:router", "explanation": "The `debug:router` command displays a list of all registered routes in a Symfony application."}

{"answer": "no", "explanation": "Symfony autowiring automatically resolves constructor dependencies from type-hints, so services do not need to be manually declared in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes and caches them in a cache directory between requests for performance."}

{"answer": "yes", "explanation": "In Symfony's dev environment, the framework tracks the files that affect container compilation (service definitions, parameters, config) and only recompiles the DI container when those tracked files change rather than on every request."}

{"answer": "APP_ENV", "explanation": "The APP_ENV environment variable selects the active Symfony runtime environment such as dev or prod."}

{"answer": "no", "explanation": "Symfony's ControllerResolver only allows public controller methods—it throws an exception if the referenced method is private or protected."}

{"answer": "no", "explanation": "Event subscribers do not automatically receive events before listeners; both listeners and subscribers use the same priority sorting system in the EventDispatcher, where higher priority values are executed first regardless of whether they are listeners or subscribers."}

{"answer": "yes", "explanation": "In Symfony 6.0, the old guard authentication system was removed, leaving only the newer AuthenticatorInterface-based authenticator system that was introduced in 5.8."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute (Symfony\\Component\\Security\\Http\\Attribute\\IsGranted) checks a role or permission on a controller method and returns a 403 when access is denied."}

{"answer": "yes", "explanation": "Voters are indeed Symfony's authorization mechanism that evaluates whether a user can perform an action on a specific subject/object, typically invoked via isGranted() with the object passed as the subject argument."}

{"answer": "yes", "explanation": "In Symfony 7.0, annotation support was fully removed from the Validation component, so constraints must be declared using PHP attributes (with YAML/XML still available as alternatives)."}

```json ⏎ {"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default (the 'csrf_protection' option defaults to true), so the form validates the submitted token when provided."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Symfony forms always validate data on the server regardless of client-side HTML5 checks, since browser validation can be easily bypassed and is not reliable for security."} ⏎ ```

{"answer": "make:form", "explanation": "The Symfony MakerBundle's `make:form` command generates a new form class (FormType) for you."}

{"answer": "no", "explanation": "Symfony does not store user passwords in the session; passwords are stored hashed in the user provider and the session contains only an authenticated user reference, not plaintext credentials."}

{"answer": "yes", "explanation": "In Symfony, bundle configuration is conventionally placed in the config/packages directory with one YAML file per bundle or topic, such as framework.yaml, doctrine.yaml, or security.yaml."}

{"answer": "yes", "explanation": "By convention in Symfony and similar PHP frameworks, the committed .env file holds default (dev) values while the git-ignored .env.local contains environment-specific real secrets and overrides."}

{"answer": "debug:container", "explanation": "The `debug:container` command displays all registered services and their aliases in the Symfony container."}

{"answer": "yes", "explanation": "The container's setParameter() method exists and modifies the ParameterBag at runtime, so it can be called from a controller, though in production the compiled/frozen container won't reflect the change in already-inlined service definitions."}

```json ⏎ {"answer": "no", "explanation": "Since Symfony 4, services are private (public: false) by default and cannot be fetched directly from the container unless explicitly configured as public."} ⏎ ```

{"answer": "no", "explanation": "Bundles have default configurations and can function without an explicit config file in config/packages, so configuration is not mandatory."}

{"answer": "yes", "explanation": "In Symfony, environment variables are injected into services.yaml using the %env(VAR)% syntax, which allows services to reference values set in the environment."}

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable controls whether Symfony runs in debug mode, which activates the profiler and Twig debugging features."}

{"answer": "no", "explanation": "A single message type can be handled by multiple handlers, which is a common and supported pattern in Symfony Messenger."}

{"answer": "no", "explanation": "The sync transport processes the message immediately within the current request rather than sending it to a transport queue for a worker to consume, unlike async."}

```json ⏎ {"answer": "messenger:consume", "explanation": "The `php bin/console messenger:consume` command starts the worker that consumes and processes messages from the Symfony Messenger queue."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy (max_retries, delay, multiplier, etc.) is configured per transport in the framework.messenger configuration."}

{"answer": "no", "explanation": "Symfony Messenger's DefaultSerializer uses PHP's native serialize() function by default, not JSON."}

{"answer": "yes", "explanation": "Symfony's Scheduler component generates messages based on schedule generators and dispatches them through the Messenger component for handling."}

{"answer": "doctrine", "explanation": "The Doctrine transport in Symfony's Messenger component stores messages in database tables managed via Doctrine ORM."}

{"answer": "yes", "explanation": "Symfony Messenger allows you to register custom middleware and control their position (via tag priority) relative to the built-in middleware in the pipeline."}

{"answer": "yes", "explanation": "Symfony follows this exact schedule: major releases occur every two years (in February), with minor releases occurring in May (short support) and November (LTS, long support) roughly every six months."}

{"answer": "8.4", "explanation": "Symfony 8.0 requires PHP 8.4 as its minimum version, following Symfony's convention of requiring relatively recent PHP releases."}

{"answer": "no", "explanation": "Symfony 7.0 removed annotation support (which was deprecated in 6.4), requiring the use of PHP attributes instead for validation and routes."}

{"answer": "yes", "explanation": "Symfony's AssetMapper manages CSS/JS assets natively without requiring node or webpack, using importmap.php to configure and resolve asset imports."}

{"answer": "no", "explanation": "Symfony 6.4 is a Long-Term Support (LTS) release, not a regular short-term release."}

```json ⏎ {"answer": "no", "explanation": "In Symfony, major versions are exactly when deprecated code and its deprecation warnings are removed, not kept — deprecations from the previous branch are cleared out during the major release process."} ⏎ ```

{"answer": "yes", "explanation": "Symfony provides an UPGRADE guide documenting breaking changes and migration steps for each major version."}

{"answer": "Asset Mapper (symfony/asset-mapper)", "explanation": "The Symfony Asset Mapper component manages frontend assets and importmaps natively without requiring node or webpack."}

{"answer": "no", "explanation": "Symfony 8.2 is scheduled for May 2027, so as of November 2026 it would not yet be released (only 8.0 LTS in May 2026 and 8.1 in November 2026 would exist)."}

{"answer": "no", "explanation": "Symfony follows a six-month cycle with LTS releases in February and non-LTS releases in August, so version 8.2 would be scheduled for February 2027, not November 2026."}

{"answer": "8.2", "explanation": "Symfony uses a major.minor versioning scheme, so the version following 8.1 is 8.2."}

```json ⏎ {"answer": "no", "explanation": "Symfony uses calendar versioning where even minor versions (like 8.2) are stable minor releases, not major releases—major releases are marked by a version like 8.0."} ⏎ ```

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "PHP's backwards compatibility policy ensures minor version releases within the same major line (like 8.1 → 8.2) preserve backward compatibility, so existing code keeps working even when features are merely deprecated rather than removed." ⏎ } ⏎ ```

{"answer": "8.4", "explanation": "In Symfony's versioning scheme, each major branch (like 8.x) has minor releases ending in 8.4 before the next major version 9.0 is released."}

{"answer": "no", "explanation": "There is no confirmed requirement that Symfony 8.2 requires PHP 8.5, as PHP 8.5 is not yet released and Symfony 8.0 (not 8.2) is the upcoming major version, so this claim is speculative."}

```json ⏎ {"answer": "yes", "explanation": "Symfony's extended deprecation policy states that deprecations introduced in the 8.x branch will not be removed before Symfony 9.0."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "The {{ }} syntax in Twig only outputs expressions (variables, function calls, etc.), while arbitrary PHP code statements must be placed inside the {% %} block syntax."} ⏎ ```

{"answer": "yes", "explanation": "Twig enables autoescaping by default for HTML templates, so printed variables are escaped to prevent XSS attacks."}

{"answer": "yes", "explanation": "The Twig |e filter escapes a string for safe output, defaulting to HTML escaping context."}

{"answer": "format_number", "explanation": "In Twig's intl-extra package, the format_number filter formats a number according to a given locale."}

```json ⏎ {"answer": "yes", "explanation": "The .raw filter in Twig marks a value as safe HTML, disabling auto-escaping for that value."} ⏎ ```

{"answer": "yes", "explanation": "In Twig, the double curly braces {{ }} are used to print output the value of an expression, while the percent-brace {% %} tags execute control logic such as if conditions, for loops, and set assignments."}

{"answer": "no", "explanation": "In Twig you can declare variables inside a template using the set tag, so values don't only come from the controller."}

{"answer": "dump", "explanation": "The Twig dump() function outputs the debug structure of a variable such as an array or object."}

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JavaScript library providing ready-made UI components like buttons, navbars, and modals, but it does not provide the routing, state management, or component-based architecture that defines an SPA framework like React or Vue."}

{"answer": ".container", "explanation": "The .container class in Bootstrap is a responsive container that applies a fixed max-width at each grid breakpoint."}

{"answer": "no", "explanation": "Bootstrap uses a 12-column grid (not 16), and modern Bootstrap (4/5) is built on Flexbox rather than CSS floats."}

{"answer": "yes", "explanation": "Bootstrap 5 defines five named breakpoints: sm, md, lg, xl, and xxl."}

{"answer": "yes", "explanation": "Bootstrap generates spacing utilities from the $spaces map, whose values are defined as multiples (including fractional ones) of $spacer, so .mt-3 equals 3 × $spacer (3rem by default)."}

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the `data-bs-toggle` attribute (with a value like `dropdown`, `modal`, or `collapse`) is used to enable an interactive component on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 removed jQuery as a dependency and its components are built using vanilla JavaScript."}

{"answer": "yes", "explanation": "In Bootstrap 5.3, applying the .dark class to the root (HTML) element enables the dark color theme."}

{"answer": "no", "explanation": "Doctrine ORM does not create tables automatically at runtime; you must generate and apply the schema using the schema tool (e.g., 'orm:schema-tool:create') beforehand."}

{"answer": "persist()", "explanation": "The persist() method registers a new object as managed and schedules it for insertion, deferring SQL execution until flush() is called."}

```json ⏎ {"answer": "false", "explanation": "The EntityManager::merge() method was deprecated in Doctrine ORM 2.11 and completely removed in Doctrine ORM 3.0."} ⏎ ```

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is an object-oriented query language that works with entities and their properties rather than database tables and columns, which is the fundamental difference from SQL."}

```json ⏎ {"answer": "null", "explanation": "Doctrine's repository->find() method returns null when no entity exists with the specified identifier."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "DoctrineBundle does not automatically call flush(); you must explicitly invoke $entityManager->flush() whenever you want persisted changes to be written to the database."} ⏎ ```

{"answer": "yes", "explanation": "For a managed entity, Doctrine's Unit of Work uses deferred implicit change tracking, so flush() automatically detects and persists property changes without needing an explicit persist() call."}

{"answer": "no", "explanation": "In Doctrine ORM, remove() merely marks the entity for deletion by adding it to the Unit of Work's removal set; the actual SQL DELETE is only executed when flush() is called."}

{"answer": "no", "explanation": "PostgreSQL uses MVCC specifically so that readers do not block writers and writers do not block readers, allowing concurrent reads and writes without locking."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command displays a query's execution plan without actually running the query."}

{"answer": "no", "explanation": "SERIAL and GENERATED AS IDENTITY are not the same: SERIAL creates a sequence with a default nextval() call, while IDENTITY follows the SQL standard with separate control over identity behavior and more features, though SERIAL's use is discouraged."}

{"answer": "no", "explanation": "In PostgreSQL, NULL values are considered distinct from each other, so a UNIQUE constraint permits multiple rows containing NULL in the column."}

{"answer": "STRING_AGG", "explanation": "STRING_AGG is the PostgreSQL aggregate function that concatenates a set of string values into a single string, joined by a specified delimiter."}

{"answer": "no", "explanation": "Plain VACUUM reclaims space occupied by dead tuples only for internal reuse within the table, whereas VACUUM FULL (or VACUUM (DEALLOCATE UNUSED)) is what returns unused space back to the operating system."}

{"answer": "PARTITION BY", "explanation": "The PARTITION BY keyword in a window function's OVER clause divides rows into groups that each function is computed over."}

{"answer": "no", "explanation": "READ COMMITTED only prevents dirty reads; non-repeatable reads are prevented by the REPEATABLE READ isolation level."}

{"answer": "yes", "explanation": "By default PostgreSQL uses autocommit mode, so each standalone SQL statement is automatically wrapped in its own implicit transaction and committed immediately."}

{"answer": "COMMIT", "explanation": "The COMMIT command ends a transaction and permanently saves all changes made during it to the database."}

{"answer": "yes", "explanation": "Indexes speed up SELECT, and also UPDATE and DELETE operations that search on an indexed column, because the index helps locate matching rows quickly instead of scanning the entire table."}

{"answer": "yes", "explanation": "SAVEPOINT in PostgreSQL lets you create a marker within a transaction so you can ROLL BACK TO that point to undo only part of the transaction without discarding the entire transaction."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports real execution statistics and timings, whereas plain EXPLAIN shows only the plan without executing."}

{"answer": "pgvector", "explanation": "The pgvector extension adds vector data types and indexing (such as IVF and HNSW) to PostgreSQL for vector similarity search, which is commonly used for embedding-based semantic search."}

{"answer": "yes", "explanation": "A partial index only includes index entries for rows that satisfy the WHERE predicate condition, making it smaller and faster to query for that subset."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE via Serializable Snapshot Isolation (SSI), which detects serialization conflicts and raises serialization failure errors rather than locking the rows a transaction reads."}

{"answer": "yes", "explanation": "HTTP 201 Created indicates the request succeeded and resulted in a new resource being created."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates a successful request with no body to return, commonly used after a DELETE operation."}

{"answer": "yes", "explanation": "DELETE is an idempotent HTTP method because repeatedly deleting the same resource results in the same state (the resource is gone), matching the HTTP specification's definition of idempotency."}

{"answer": "no", "explanation": "The Access-Control-Allow-Origin header is sent by the server in the response, not by the client, to indicate which origins are allowed to access the resource."}

{"answer": "yes", "explanation": "HTTP status 429 Too Many Requests is defined by RFC 6585 as the response indicating that the user has sent too many requests in a given amount of time, triggering rate limiting."}

{"answer": "no", "explanation": "The statement is reversed: 4xx codes indicate client errors while 5xx codes indicate server-side errors."}

{"answer": "Content-Type", "explanation": "The Content-Type HTTP header specifies the MIME type of the resource being sent in a request or response body."}

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not required to be idempotent, unlike PUT which is required to be idempotent per RFC 7231."}

{"answer": "no", "explanation": "Using == is insufficient because it is vulnerable to timing attacks; hashes should be compared with the constant-time hash_equals() function."}

{"answer": "yes", "explanation": "A CSRF token is generated by the server and stored in the session, then validated server-side on unsafe requests like POST to ensure the request originated from a legitimate form submission rather than a forged external site."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header allows site administrators to control the resources a user agent is permitted to load, thereby enabling the Content Security Policy."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework that grants access to resources, not an authentication protocol, and the access token does not inherently identify who the user is."}

{"answer": "no", "explanation": "XSS is primarily prevented by encoding output (escaping) when rendering data in the appropriate context (HTML, JavaScript, etc.), not by sanitizing input before database storage, since the same data can be safely or dangerously interpreted depending on where and how it is displayed."}

{"answer": "code", "explanation": "In the OAuth 2.0 authorization code flow, the authorization code (the \"code\" query parameter) is delivered to the redirect_uri and then exchanged at the token endpoint for an access token."}

{"answer": "yes", "explanation": "Refresh tokens are designed to have a longer lifespan than access tokens and are specifically used to obtain new access tokens without requiring the user to re-authenticate."}

{"answer": "no", "explanation": "Password salts do not need to be secret and are typically stored alongside the hash; the security benefit comes from defeating rainbow tables and ensuring unique hashes, not from secrecy."}

{"answer": "yes", "explanation": "PHPUnit discovers test methods via naming conventions or @test annotations through reflection, so a class does not need to extend TestCase for its test methods to be discovered and run (though TestCase is needed for assertion helpers)."}

{"answer": "no", "explanation": "In PHPUnit, setUp() runs before each individual test method, not once before all tests of the class."}

{"answer": "no", "explanation": "A data provider allows a test to run multiple times, once for each set of arguments it returns, not just one."}

{"answer": "expectException", "explanation": "The expectException() method declares that a specific exception class is expected to be thrown during a test."}

```json ⏎ {"answer": "no", "explanation": "The statement is backwards: a stub only returns predefined data, while a mock is used to verify which methods were called on it."} ⏎ ```

{"answer": "yes", "explanation": "In PHPUnit 10, metadata annotations like @dataProvider were deprecated in favor of PHP attributes such as #[DataProvider]."}

{"answer": "no", "explanation": "PHPUnit allows test dependencies through the @depends annotation, which lets one test run after and receive the result of another."}

{"answer": "--order-by=random", "explanation": "The --order-by=random option in PHPUnit randomizes the order in which tests are executed."}

{"answer": "3-3", "explanation": "intdiv(7,2) returns 3 and intdiv(-7,2) returns -3 (truncated toward zero), which concatenate to \"3-3\"."}

{"answer": "-9", "explanation": "In PHP, the exponentiation operator `**` has higher precedence than the unary minus, so `-3 ** 2` is evaluated as `-(3 ** 2)`, yielding -9."}

```json ⏎ {"answer": "true", "explanation": "Both '1e1' and '10' are numeric strings (1e1 = 10 in scientific notation), so PHP compares them numerically as 10 == 10, which is true."} ⏎ ```

```json ⏎ {"answer": "zero", "explanation": "The switch uses loose comparison, so 'a' is converted to 0 (non-numeric string), matching case 0."} ⏎ ```

{"answer": "2c", "explanation": "When strtr is given an array of string replacements, it matches the longest substring first, so 'ab' is replaced with '2' before 'a' is considered, leaving 'c' unchanged."}

{"answer": "[hello]", "explanation": "A negative offset in substr() counts from the end, and since -10 goes before the string's start, it returns the entire string 'hello'."}

```json ⏎ {"answer": "k,n,m", "explanation": "The + operator performs a union where the left array's keys take precedence, so $a+$b = ['k'=>1, 'n'=>2, 'm'=>3], and implode of those keys gives k,n,m."} ⏎ ```

```json ⏎ {"answer": "yxz", "explanation": "usort sorts by the third element (values 2,1,2) with PHP 8.0+ stability keeping the equal-value rows in original order, giving ['y','x','z'] which implode joins to 'yxz'."} ⏎ ```

{"answer": "4", "explanation": "The spread operator with an associative array passes named arguments by key, so $a=5 and $b=1 regardless of order, making 5-1=4."}

```json ⏎ {"answer": "3", "explanation": "The `$p->g(...)` syntax creates a closure bound to the object `$p`, which keeps a live reference to it (so nullifying `$p` doesn't destroy the object) and preserves access to the private property `$v` when invoked, returning 3."} ⏎ ```

{"answer": "B", "explanation": "static::class uses late static binding, so calling who() on a B instance returns the subclass name B rather than A."}

{"answer": "Fatal error (infinite recursion)", "explanation": "The set hook assigns to `$this->x`, which re-invokes the same set hook, causing infinite recursion and a stack overflow rather than printing a value."}

```json ⏎ {"answer": "BA", "explanation": "The `insteadof` operator resolves the conflict so f() uses TB's method returning 'B', and `as g` aliases the excluded TA::f returning 'A', giving 'B'.'A' = 'BA'."} ⏎ ```

{"answer": "0", "explanation": "Each class using a trait receives its own independent copy of the trait's static property, so setting CX::$n = 1 does not affect CY::$n, which remains its default value of 0."}

{"answer": "2", "explanation": "In PHP, a return statement in a finally block overrides any return value from the try block, so the function returns 2."}

{"answer": "second", "explanation": "The inner try throws RuntimeException, but the finally block throws LogicException which replaces the original exception and propagates to the outer catch that catches LogicException and echoes 'second'."}

{"answer": "App\\Foo|Baz", "explanation": "Inside namespace N, the alias `Baz` refers to `App\\Foo`, so `Baz::class` resolves to `App\\Foo`; while `\\Baz::class` references the global (nonexistent) class `Baz`, and since the `::class` operator resolves names at compile time without requiring the class to exist, it simply yields the string `Baz`."}

{"answer": "yesyes", "explanation": "Both class_exists calls resolve to Ns\\Foo: the unqualified string 'Foo' is resolved to the current namespace Ns\\Foo, and the explicitly qualified string Ns\\Foo also matches, so both return true."}

```json ⏎ {"answer": "1,2,99", "explanation": "After the foreach loop, the reference variable $v remains bound to the last element ($a[2]), so $v = 99 overwrites $a[2] to 99, resulting in the array [1, 2, 99]."} ⏎ ```

{"answer": "3", "explanation": "The static variable $n is bound to the method A::inc(), not to any instance, and since B inherits inc() without overriding it, all calls share the same $n, incrementing 1, 2, then 3."}

{"answer": "11", "explanation": "Calling $g->send(10) resumes the generator, making the yield expression evaluate to 10 so $x = 10, and the function returns $x + 1 = 11, which getReturn() retrieves."}

{"answer": "1,2,ok", "explanation": "outer() delegates to inner() via yield from (yielding 1 and 2), then the yield from expression equals the return value 'ok' which is also yielded, so the collected values are 1, 2, ok."}

{"answer": "noyes", "explanation": "The hash is created with cost 4, so the first check (cost 4) matches and returns false ('no'), while the second check (cost 5) doesn't match and returns true ('yes')."}

{"answer": "strict-in", "explanation": "E_ALL (32767) includes the E_STRICT bit (2048), so (E_ALL & 2048) equals 2048, which is not === 0, thus the ternary evaluates to 'strict-in'."}

```json ⏎ {"answer": "mapped", "explanation": "The 'HTTP_X_TOKEN' server variable passed to Request::create is converted by Symfony into an 'X-Token' header, so $r->headers->get('X-Token') returns 'abc'."} ⏎ ```

{"answer": "BCA", "explanation": "Symfony's EventDispatcher runs listeners with higher priorities first, so B (priority 10), then C (priority 5), then A (priority 0)."}

{"answer": "same", "explanation": "Doctrine's UnitOfWork caches managed entities in an identity map keyed by primary key, so the second find() returns the same instance as the first, making the object IDs identical."}

```json ⏎ {"answer": "0", "explanation": "persist() schedules the new entity for insertion, but remove() before flush() cancels that schedule (clearing it from the insertions queue), so nothing is ever inserted and the users table stays empty."} ⏎ ```

{"answer": "1", "explanation": "count(x) counts only non-NULL values of x, and only the value 1 is non-NULL, so it returns 1."}

{"answer": "10,30,60", "explanation": "The inner query computes the running sum of x ordered by id (10, 30, 60), and string_agg concatenates these values as text ordered by id, yielding \"10,30,60\"."}

{"answer": "0", "explanation": "The second constructor argument of `HandlerDescriptor` is `dispatchThroughBus`, not `aliases`, so passing `['alias' => 'h1']` makes it truthy, causing both handlers to be skipped by `HandleMessageMiddleware` and leaving `$n` at 0."}

{"answer": "1", "explanation": "The first insert succeeds adding the row, and the second insert hits a unique index conflict and does nothing, leaving exactly one row."}

```json ⏎ {"answer": "2", "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, its integrity check is deferred until transaction commit, so both inserts succeed and the count returns 2 before any COMMIT occurs."} ⏎ ```

{"answer": "6", "explanation": "The `--filter test_sum` regex matches both `test_sum` and `test_sum_abs` (since it's a prefix), each running with 3 data providers, for a total of 6 tests."}

```json ⏎ {"answer": "2, 1", "explanation": "The data provider supplies two data sets (1 and -1), so 2 tests run; only x=-1 fails the assertTrue assertion, leaving 1 failure."} ⏎ ```

{"answer": "POST", "explanation": "The `-d`/`--data` flag in curl sends data in the request body using the HTTP POST method by default."}

{"answer": "GET", "explanation": "The -G flag appends the data (-d) to the URL as a query string and changes the request method from POST to GET."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 §5.2, when client authentication fails—including when the client_id does not exist or is unrecognized—the token endpoint returns an \"invalid_client\" error."}

```json ⏎ {"answer": "fragment", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access_token is returned in the URL fragment (the part after the # symbol), which is never sent to the server and is instead handled by the client-side JavaScript."} ⏎ ```

{"answer": "6", "explanation": "The `default` filter returns `2` because Twig treats `false` as empty, then `2 * 3` evaluates to `6`."}

{"answer": "no", "explanation": "The + operator has higher precedence than ~, so the expression evaluates as 'a' ~ (1 + 2) = 'a3', which concatenates successfully and throws no exception."}

{"answer": "1", "explanation": "The NotBlank constraint is applied to the array `['']`; since the array itself isn't blank, the validator traverses it with the default inherit strategy and flags the single empty-string element as a violation, resulting in one violation."}

{"answer": "Symfony\\Component\\Form\\Exception\\InvalidConfigurationException", "explanation": "isValid() throws an InvalidConfigurationException because the form was never submitted via submit(), and the catch block echoes the exception's class name."}

{"answer": "hi Bob!", "explanation": "ContainerBuilder resolves nested parameter placeholders recursively, so '%greeting'!' resolves to 'hi %name'!' then to 'hi Bob'!"}

```json ⏎ {"answer": "960px", "explanation": "In Bootstrap 5.3, the .container reaches its 'lg' breakpoint at min-width 992px, which sets the max-width to 960px."} ⏎ ```

{"answer": "text-danger", "explanation": "Both classes have equal specificity (0,1,0), so the cascade is decided by stylesheet source order, where `.text-danger` is generated after `.text-primary` (following the $theme-colors map order: primary, secondary, success, danger, ...), thus it wins."}

```json ⏎ {"answer": "2", "explanation": "OrderService is in the Domain layer, which may only depend on Domain, so using both App\\Application\\PlaceOrder and App\\Infrastructure\\Db counts as two violations."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "BillingService is in the Domain layer, which may only depend on Domain, so its three external dependencies (App\\Application\\PlaceOrder, App\\Infrastructure\\Db, and App\\Infrastructure\\Logger) each constitute one violation."} ⏎ ```

{"answer": "10,15", "explanation": "The constructor promotes a readonly int property, add returns a new Money with the summed amount (15), so echoing $a->amount (10) and $c->amount (15) yields 10,15."}

{"answer": "1", "explanation": "The add() sets one item, then remove() detects count===1 and throws DomainException before unset(), which is caught, so count() still returns 1."}

{"answer": "hi", "explanation": "The code instantiates class C, immediately calls its hi() method which returns the string 'hi', and echo outputs that value."}

{"answer": "yeno", "explanation": "`newLazyGhost` creates an uninitialized lazy ghost object, so the first check prints 'yes'; accessing `$o->v` triggers the initializer (setting `$v = 21`) and initializes the object, so the second check prints 'no', giving the concatenated output 'yeno'."}

{"answer": "no", "explanation": "The Guard authentication system (including `AbstractGuardAuthenticator`) was deprecated in Symfony 5.3 and completely removed in Symfony 6.0, so it does not exist in Symfony 8.1."}

{"answer": "noyes", "explanation": "In Symfony 8.x, the annotation-based `AnnotationClassLoader` was removed (annotations support was dropped in favor of attributes), while the attribute-based `AttributeClassLoader` still exists."}