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

{"answer": "no", "explanation": "Double-quoted strings process variable interpolation and escape sequences, while single-quoted strings only interpret \\ and \' escapes, so they are not processed identically."}

{"answer": "yes", "explanation": "The null coalescing operator (??) follows isset semantics and does not raise a warning for undefined variables."}

```json ⏎ {"answer": "ab", "explanation": "echo can accept multiple comma-separated arguments which are concatenated and output together."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, print always returns 1 and, unlike echo, it can be used inside an expression."}

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

{"answer": "yes", "explanation": "In PHP, the concatenation operator (.) has lower precedence than the addition (+) and subtraction (-) operators, which is why expressions like '1 + 2 . foo' evaluate as '(1 + 2) . foo' rather than '1 + (2 . foo)'."}

{"answer": "no", "explanation": "In PHP the ** operator is right-associative, so 2 ** 3 ** 2 evaluates as 2 ** (3 ** 2) = 2 ** 9 = 512, not 64."}

{"answer": "3", "explanation": "Concatenation (.) has higher precedence than addition (+), so it evaluates as ('sum: ' . 2) + 3, which gives 'sum: 2' + 3; the non-numeric string converts to 0, so 0 + 3 = 3."}

{"answer": "no", "explanation": "With strict comparison (===), arrays must have the same key/value pairs in the same order to be considered equal, so element order matters."}

{"answer": "no", "explanation": "The statement is false: 0 == false returns true in PHP, and == is a loose (non-strict) comparison operator, whereas === is the strict one."}

{"answer": "yes", "explanation": "In PHP, loose comparison of a non-numeric string with a number converts the string to 0, so \"abc\" == 0 evaluates to true."}

{"answer": "yes", "explanation": "Under PHP's loose comparison, null is treated as an empty value, so null == 0, null == \"\", and null == false all evaluate to true."}

```json ⏎ {"answer": 42, "explanation": "In PHP, casting a string with a numeric prefix to int extracts the leading numeric portion, so (int) '42abc' returns 42."} ⏎ ```

```json ⏎ {"answer": 10, "explanation": "In PHP, the '+' operator forces numeric context, so the string '5' is converted to the number 5 and added to 5, resulting in 10."} ⏎ ```

{"answer": "no", "explanation": "When cast to string, false becomes an empty string (\"\"), not \"0\"; it is true that becomes \"1\"."}

{"answer": "yes", "explanation": "Due to floating-point precision, 0.1 + 0.2 evaluates to 0.30000000000000004, which is not identical to 0.3, so the strict comparison returns false."}

{"answer": "no", "explanation": "strrev() reverses bytes individually, so multibyte UTF-8 characters get scrambled rather than reversed correctly (you'd need mb_strrev() instead)."}

```json ⏎ {"answer": "yes", "explanation": "str_contains() returns true when the haystack string contains the needle string, and 'Hello world' does contain 'world'."} ⏎ ```

{"answer": "no", "explanation": "str_pad() can pad on the left (STR_PAD_LEFT), right (STR_PAD_RIGHT, the default), or both sides (STR_PAD_BOTH), not the right side only."}

{"answer": "no", "explanation": "By default, PHP's trim() removes not only spaces but also tabs, newlines, carriage returns, NUL-bytes, and vertical tabs."}

{"answer": "6", "explanation": "strlen counts bytes, not characters, and the é character takes 2 bytes in UTF-8 (h=1, é=2, l=1, l=1, o=1)."}

{"answer": "def", "explanation": "In PHP's substr(), a negative offset counts from the end of the string, so -3 means start 3 characters from the end, returning the last 3 characters 'def'."}

{"answer": "no", "explanation": "In PHP strings are immutable, so ucfirst() returns a new string with the first character capitalized without modifying the original in place."}

{"answer": "yes", "explanation": "Heredoc (<<<EOT) interpolates variables like double quotes, while nowdoc (<<<'EOT') does not interpolate variables, behaving like single-quoted strings."}

{"answer": "no", "explanation": "sort() reindexes the array with sequential integer keys and does not preserve the key-to-value association (that's what asort() does)."}

{"answer": "yes", "explanation": "In PHP, string array keys that are valid decimal integer strings (without leading zeros) are automatically converted to integer keys."}

{"answer": "no", "explanation": "in_array() uses loose (non-strict) comparison by default; you must pass true as the third parameter to enable strict comparison."}

```json ⏎ {"answer": "yes", "explanation": "Without a callback, array_filter() uses the default behavior of testing each element as a boolean and removing all falsy (empty) values from the array."} ⏎ ```

{"answer": "no", "explanation": "By default, array_slice() re-indexes the array numerically from 0, so original keys are not preserved unless the $preserve_keys parameter is set to true."}

{"answer": "[20, 30]", "explanation": "array_slice extracts a portion starting at offset 1 and takes 2 elements, returning [20, 30] with reindexed keys."}

```json ⏎ {"answer": "2", "explanation": "The union operator (+) keeps the left array's values for matching keys and appends only the right array's new keys, so the result is ['a' => 1, 'b' => 2] which has 2 elements."} ⏎ ```

{"answer": "yes", "explanation": "Since PHP 8.1, the spread operator works with associative arrays that have string keys, not just numerically indexed arrays."}

```json ⏎ {"answer": "false", "explanation": "As of PHP 8.1, named arguments can be combined with argument unpacking (...$args) in a single call, such as foo(a: 1, ...['b' => 2, 'c' => 3]);."} ⏎ ```

{"answer": "no", "explanation": "In PHP, anonymous functions (closures) do not automatically inherit outer scope variables; they must be explicitly imported using the use keyword."}

{"answer": "3", "explanation": "func_num_args() returns the total number of arguments actually passed to the function, which is 3 regardless of the single declared parameter."}

```json ⏎ {"answer": "no", "explanation": "Arrow functions in PHP have only a concise single-expression body with no curly-brace block."} ⏎ ```

{"answer": "no", "explanation": "In PHP, arrow functions capture outer variables by value automatically (not by reference), unless you explicitly prefix them with & to capture by reference."}

```json ⏎ {"answer": "yes", "explanation": "Declaring a closure as static detaches it from the enclosing scope's $this, so it cannot access $this and does not capture it."} ⏎ ```

{"answer": "5", "explanation": "Closures capture variables by value at the time they are created, so $f captures 5 before $x is reassigned to 7."}

{"answer": "yes", "explanation": "In weak typing mode, PHP performs automatic type coercion, so the string \"5\" is coerced to the integer 5 when passed to an int parameter."}

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, which allows declaring and assigning properties directly in the constructor parameters."}

{"answer": "final", "explanation": "The `final` keyword prevents a method or class from being overridden or extended by subclasses."}

{"answer": "yes", "explanation": "In PHP, declaring a method as final prevents it from being overridden by any subclass."}

{"answer": "false", "explanation": "Private properties are only accessible within the class that defines them and are not directly accessible from any subclass."}

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

```json ⏎ {"answer": "yes", "explanation": "Private methods are scoped only to their declaring class, so they don't form part of the inheritance contract, and a child class can declare a same-named method with any visibility without conflict."} ⏎ ```

{"answer": "no", "explanation": "__get() is triggered not only for non-existent properties but also for properties that exist yet are inaccessible (private/protected) from the current scope."}

{"answer": "Error", "explanation": "In PHP 8.1+, reassigning a readonly property after it has been set throws an Error (specifically a Cannot reassign readonly property Error), not a regular Exception."}

{"answer": "yes", "explanation": "In PHP, interfaces can declare constants, which since PHP 7.1 are implicitly public."}

```json ⏎ {"answer": "instanceof", "explanation": "The instanceof operator in PHP is used to determine whether an object is an instance of a particular class or interface."} ⏎ ```

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces are allowed to declare static methods, which must be implemented by the classes that use the interface."}

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

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces are allowed to have methods with default implementations, similar to how trait methods can be overridden."}

{"answer": "yes", "explanation": "In PHP, an abstract method in an abstract class can be declared with public, protected, or private visibility."}

{"answer": "3", "explanation": "Foo::cases() returns an array containing all enum cases, and since Foo defines exactly three cases (A, B, C), the array has 3 elements."}

{"answer": "yes", "explanation": "PHP traits can declare constants along with properties and methods."}

{"answer": "yes", "explanation": "In PHP 7+, both the Exception and Error classes implement the Throwable interface, making Throwable their common ancestor."}

{"answer": "no", "explanation": "TypeError extends Error, not Exception, so catching Exception will not catch TypeError."}

{"answer": "false", "explanation": "The @ operator only suppresses PHP runtime errors/warnings, not exceptions, which are handled via try/catch blocks."}

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) triggers a division by zero which PHP throws as a DivisionByZeroError exception."}

{"answer": "no", "explanation": "The finally block always executes regardless of whether an exception was thrown or caught, or even if there is no catch block at all."}

{"answer": "no", "explanation": "An exception thrown inside a finally block propagates and overrides the normal result or return value of the try block, so it does have an effect."}

{"answer": "yes", "explanation": "In PHP, casting any object (including an Exception) to a boolean always returns true, regardless of its properties."}

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

{"answer": "no", "explanation": "The `use` statement only creates an alias/imports a namespace reference; the actual class file is loaded lazily by the autoloader when the class is first referenced, not by the `use` statement itself."}

{"answer": "function", "explanation": "In PHP, to import a function from a namespace you write `use function`, whereas `use const` is used for constants and nothing is needed for classes."}

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps the App\\ namespace prefix to src/, so the class App\\Controller\\Api\\UserController is located at src/Controller/Api/UserController.php, meaning from src/ the path is Controller/Api/UserController.php."}

```json ⏎ {"answer": "yes", "explanation": "Composer's vendor/autoload.php loads autoloader definition files (like autoload_real.php) which register classmap, PSR-4, and files autoloaders through spl_autoload_register()."} ⏎ ```

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

```json ⏎ {"answer": "no", "explanation": "An unqualified class name in a new expression is resolved relative to the current namespace (with fallback to the global namespace), not from the global root—only a fully qualified name with a leading backslash is resolved from the global root."} ⏎ ```

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

```json ⏎ {"answer": "yes", "explanation": "In PHP, the use statement can be written inside a function body to import a namespace locally, and that import applies only within that function's scope."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, arrays use copy-on-write semantics, so assigning an array to another variable copies its value rather than creating a reference to it."}

{"answer": "2", "explanation": "PHP arrays use copy-on-write, so assigning $b = $a does not copy until $b is modified, leaving $a unchanged."}

{"answer": "yes", "explanation": "In PHP, variables defined outside a function have global scope and are not automatically available inside a function's local scope; you must use the global keyword, the $GLOBALS superglobal array, or pass them as parameters to access them."}

{"answer": "no", "explanation": "Unsetting $GLOBALS['x'] removes the global variable entirely from all scopes, not just the current function, because $GLOBALS holds actual references to global variables."}

```json ⏎ {"answer": "6", "explanation": "The function parameter is passed by reference, so $x++ modifies the original $n variable, changing it from 5 to 6."} ⏎ ```

{"answer": "no", "explanation": "A foreach by value operates on a copy of the array, so modifications inside the loop are not visible in the same pass; only foreach by reference operates on the live array."}

```json ⏎ {"answer": "no", "explanation": "A static property belongs to the class itself and is shared by all instances, so a change made through one object IS visible in all other objects."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "In PHP, array keys must be integers or strings, so a boolean key like true is coerced to the integer 1 rather than being stored as a bool."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, a generator can return a value with 'return $value;', and once the generator is exhausted, that value is accessible via the Generator::getReturn() method."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, a fully consumed Generator implements RewindableIterator, so calling rewind() restarts the generator function from the beginning, allowing it to produce the same values again."} ⏎ ```

{"answer": "yes", "explanation": "The `yield from` construct delegates iteration to another generator or iterable, forwarding values between the caller and the sub-iterable."}

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

{"answer": "3", "explanation": "The generator yields the three array values 1, 2, 3 via `yield from`, and iterator_to_array converts them into a 3-element array, so count() returns 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (Last In First Out) stack, not a FIFO queue, which is what SplQueue provides."}

{"answer": "yes", "explanation": "ArrayIterator is an SPL class that implements the Iterator interface, allowing an array to be wrapped and traversed using iterator methods like current(), key(), next(), rewind(), and valid()."}

{"answer": "no", "explanation": "ArrayObject implements the Iterator interface, so it can be traversed directly with foreach."}

{"answer": "yes", "explanation": "password_hash() automatically generates and uses a random salt internally, so passing your own salt via the 'salt' option is unnecessary and not recommended."}

```json ⏎ {"answer": "no", "explanation": "PASSWORD_DEFAULT in PHP 8 uses Argon2id (Bcrypt before PHP 8.0), not MD5."} ⏎ ```

{"answer": "yes", "explanation": "password_verify returns true when the plain-text password matches the hash produced by password_hash, and both use the same secret."}

{"answer": "no", "explanation": "strip_tags() only removes HTML and PHP tags, so it has no effect on SQL injection, which requires parameterized queries or escaping user input for SQL."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID after login, preventing an attacker from using a pre-set (fixed) session ID against the user."}

{"answer": "php_sapi_name()", "explanation": "The built-in function php_sapi_name() returns the name of the SAPI (Server Application Programming Interface) the PHP engine is running under, such as \"cli\", \"apache2handler\", or \"fpm-fcgi\"."}

{"answer": "yes", "explanation": "session_destroy() only clears the server-side session data but leaves the browser's session cookie intact, so you must separately expire the cookie if you want it removed."}

{"answer": "no", "explanation": "Session data is only loaded into the $_SESSION array after session_start() is called, which initializes the session and deserializes stored data."}

```json ⏎ {"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3 as part of the new array search functions (array_find, array_find_key, array_some, array_every)."} ⏎ ```

{"answer": "yes", "explanation": "Property hooks (get/set/setter/getter/init/pre_get etc.) were indeed introduced in PHP 8.4."}

{"answer": "false", "explanation": "Asymmetric visibility (e.g., public(set) and private(set)) was introduced in PHP 8.2, not PHP 8.4."}

{"answer": "8.2", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2 to warn when the return value of a function or method is discarded."}

{"answer": "8.1", "explanation": "The pipe operator (|>) was introduced as an experimental feature in PHP 8.1, allowing the value on the left to be passed as an argument to the function on the right."}

{"answer": "8.4", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) was introduced as part of the 'new with'-style enhancements proposed for PHP 8.4."}

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

```json ⏎ {"answer": "8.1", "explanation": "The RFC Partial Function Application v2 was adopted for PHP 8.1, which added the ability to partially apply functions via the rest parameter in closures."} ⏎ ```

```json ⏎ {"answer": "8.1", "explanation": "The clamp() function was implemented in PHP 8.1 following the clamp_v2 RFC."} ⏎ ```

{"answer": "no", "explanation": "PHP adopted the original Context Managers RFC (introducing the `using()` pattern and `IContextManager` interface) in PHP 8.4, but a distinct 'Context Managers v2' has not been adopted."}

{"answer": "no", "explanation": "The PHP RFC for bound-erased generic types (Generics) was accepted, not declined."}

{"answer": "false", "explanation": "As of the knowledge available, no RFC has been accepted to enable Zend Thread Safety (ZTS) by default in PHP; NTS remains the default build configuration."}

{"answer": "yes", "explanation": "PHP has consistently deferred generics (parameterized types) through versions 8.x including 8.5, with generics still not implemented as of that release."}

{"answer": "yes", "explanation": "PHP follows an annual release cycle with minor versions GA-ing in November, so PHP 8.5 (GA ~Nov 2025) is latest stable as of Nov 7, 2026, while 8.6 is not yet GA."}

{"answer": "yes", "explanation": "PHP 6 was cancelled after its Unicode support project was abandoned, so PHP 7.0 was released directly after PHP 5.6 in November 2015."}

{"answer": "false", "explanation": "The RFC adding the #[\\Deprecated] attribute to PHP core was rejected in its vote for PHP 8.4 and failed to reach the required 2/3 majority."}

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

{"answer": "yes", "explanation": "In Domain-Driven Design and clean architecture, domain entities must be pure PHP classes that depend only on the language and standard library, keeping them free of framework or ORM coupling."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation/presentation layer, not the business-logic layer, since they handle user requests and rendering while use cases themselves contain the application/business logic."}

{"answer": "Entities", "explanation": "In onion architecture the innermost layer contains the core domain entities that hold the business rules, with use cases, interface adapters, and frameworks/facilities arranged in surrounding layers."}

{"answer": "yes", "explanation": "Deptrac analyzes layer dependencies via a config file and fails (non-zero exit) when it detects a forbidden call crossing a layer boundary."}

{"answer": "no", "explanation": "Use cases should be decoupled from framework-specific types like HTTP requests or the EntityManager; they should accept plain data (DTOs/value objects) so they remain testable and independent of the outer layers, rather than being passed framework objects for the sake of simplicity."}

{"answer": "Repository", "explanation": "A Repository is the component that provides a collection of aggregates/entities while abstracting the storage mechanism behind an interface."}

{"answer": "yes", "explanation": "In clean architecture the database is an infrastructure concern in the outer layer, so swapping PostgreSQL for another database only requires changing the adapter while the domain entities and use cases remain untouched."}

{"answer": "no", "explanation": "An aggregate in DDD is a cluster of domain objects treated as a single unit with an aggregate root governing its consistency, not a database table which is a persistence concern."}

{"answer": "yes", "explanation": "Value Objects are defined by their attributes rather than a distinguishing identity, and they should be immutable so their values never change after creation."}

{"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the aggregate root is the single entry point through which all changes to the aggregate must occur, ensuring consistency and integrity of the cluster."}

{"answer": "yes", "explanation": "In DDD, repositories encapsulate a set of aggregates and are declared for aggregate roots, with entities inside an aggregate managed through the root rather than having their own repositories."}

{"answer": "yes", "explanation": "Ubiquitous language in Domain-Driven Design is indeed the shared vocabulary developed collaboratively between developers and domain experts to ensure consistent understanding across the model."}

{"answer": "possible world", "explanation": "This describes Kripke's possible-worlds semantics where within one possible world a model and its language are consistent, while across different possible worlds the same terms can designate other models."}

{"answer": "no", "explanation": "DDD recommends a rich domain model where objects encapsulate both state and behavior, not an anemic model, which Martin Fowler criticized for pushing logic out of entities into services."}

```json ⏎ {"answer": "yes", "explanation": "In Domain-Driven Design, each bounded context owns its own model, so the same concept (e.g., 'Customer' or 'Product') is intentionally represented by different classes across different contexts with distinct meanings."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony's DI container, services are lazily instantiated only when first requested and then cached as singletons, so the statement is true."}

{"answer": "debug:routes", "explanation": "The Symfony console command that lists all registered routes is `debug:routes` (also known as `router:debug` in older versions)."}

{"answer": "no", "explanation": "Symfony provides default autowiring and autoconfiguration, so most services are registered automatically through autodiscovery without needing to be manually declared in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes and caches them on disk between requests for performance."}

{"answer": "yes", "explanation": "In dev mode Symfony's kernel compares tracked files' modification timestamps and only recompiles/rebuilds the DI container when they have changed, enabling caching across requests."}

{"answer": "APP_ENV", "explanation": "In Symfony, the APP_ENV environment variable (or its .env equivalent) selects the active runtime environment such as dev or prod."}

{"answer": "no", "explanation": "In Symfony, the controller method referenced by routing must be public; private or protected methods cannot be used as controller actions."}

{"answer": "no", "explanation": "Subscribers do not automatically have priority over listeners; both listeners and subscribers receive events based on their explicitly specified numeric priority value."}

{"answer": "yes", "explanation": "The old guard authentication system was deprecated in Symfony 5.8/5.9 and fully removed in Symfony 6.0, leaving the new authenticator-based system (AuthenticatorInterface) as the approach."}

{"answer": "IsGranted", "explanation": "The #[IsGranted()] attribute verifies that the current user has a specified role or permission, throwing a 403 Forbidden exception if the check fails."}

{"answer": "yes", "explanation": "Voters are Symfony's authorization mechanism, and isGranted('EDIT', $post) is how you request access to a specific object, allowing voters to evaluate whether that access should be granted."}

{"answer": "yes", "explanation": "In Symfony 7, support for Doctrine annotations was completely removed, so validation constraints like NotBlank must now be declared using PHP attributes."}

```json ⏎ {"answer": "yes", "explanation": "Symfony enables CSRF protection by default (csrf_protection = true), automatically generating a _token field and validating it on submission."} ⏎ ```

{"answer": "yes", "explanation": "Server-side validation is always executed by Symfony regardless of client-side HTML5 checks, which only improve UX and cannot be trusted for security."}

{"answer": "make:form", "explanation": "The Symfony MakerBundle provides the `make:form` command, which generates a FormType (form class) based on a given class name and property fields."}

{"answer": "no", "explanation": "Symfony stores an authentication token (containing the user identifier) in the session, never the password, and passwords are hashed rather than stored in plain text."}

{"answer": "yes", "explanation": "In Symfony, bundle and topic configurations are typically stored in config/packages, with one file per bundle or configuration topic (e.g., framework.yaml, doctrine.yaml, security.yaml)."}

{"answer": "yes", "explanation": "This reflects a common .env pattern where the committed .env holds development defaults and the gitignored .env.local overrides it with real secrets that should never be pushed to the repository."}

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

```json ⏎ {"answer": "no", "explanation": "The Symfony service container is compiled and cached, so its parameters are frozen and immutable after boot; calling setParameter() at runtime from a controller does not work in a compiled container."} ⏎ ```

{"answer": "no", "explanation": "By default, Symfony services are private (public: false), so they cannot be fetched directly from the container unless explicitly marked as public."}

```json ⏎ {"answer": "no", "explanation": "Not every bundle requires a configuration file; many bundles work with sensible defaults and only need configuration when you want to customize their behavior."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony, environment variables are injected into config files like services.yaml using the %env(VAR)% placeholder syntax."}

{"answer": "APP_DEBUG", "explanation": "In Symfony, the APP_DEBUG environment variable (which sets the kernel debug mode) enables the profiler and Twig template debugging."}

{"answer": "no", "explanation": "A single message type in Symfony Messenger can be handled by multiple handlers, which are all invoked (fan-out pattern) rather than limited to just one."}

{"answer": "no", "explanation": "The sync transport handles messages immediately in the same process rather than queuing them for a worker to process later like the async transport does."}

{"answer": "messenger:consume", "explanation": "In Symfony's Messenger component, the `messenger:consume` command starts the worker that processes (consumes) messages from the transport queue."}

{"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy is configured per transport, allowing each transport to have its own max_retries, delay, and multiplier settings."}

{"answer": "no", "explanation": "Symfony Messenger uses the PHP serializer (PhpSerializer) by default, not JSON serialization."}

{"answer": "no", "explanation": "Symfony Scheduler runs closures or shell commands on a schedule via a Schedule object; it does not produce and dispatch messages through the Messenger component."}

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

```json ⏎ {"answer": "yes", "explanation": "Symfony Messenger's pipeline is an extensible stack of middleware that users can customize by adding custom middleware in a defined order relative to the built-in ones."} ⏎ ```

{"answer": "yes", "explanation": "Symfony follows a release schedule where minor releases occur every six months (May and November), major releases every two years, and point/bug-fix releases every two months."}

{"answer": "8.3", "explanation": "Symfony 8.0, scheduled for release in 2025, requires PHP 8.3 or higher as its minimum version."}

{"answer": "false", "explanation": "Symfony 7.0 completely removed support for docblock annotations, which were deprecated in Symfony 6.1 and replaced by PHP attributes."}

{"answer": "yes", "explanation": "Symfony's AssetMapper manages CSS/JS dependencies without requiring node or webpack, using an importmap.php file to define a browser-based import map for assets."}

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release, not a regular one, with security support extending until 2028."}

{"answer": "no", "explanation": "In Symfony, deprecations introduced in previous branches are actually removed when moving to a new major version, which is precisely the purpose of the deprecation process."}

```json ⏎ {"answer": "yes", "explanation": "Symfony always provides an UPGRADE document (UPGRADE-x.md) for its major releases that details breaking changes and migration steps."} ⏎ ```

```json ⏎ {"answer": "symfony/importmap", "explanation": "The symfony/importmap component manages front-end assets via the browser importmap API, eliminating the need for node or webpack."} ⏎ ```

{"answer": "yes", "explanation": "Symfony 8.0 released November 2025, with minor releases following a quarterly schedule (8.1 around March 2026, 8.2 around July/August 2026), so 8.2 would already be out by November 2026."}

{"answer": "no", "explanation": "Symfony 8.0 is scheduled for November 2026, but Symfony 8.2 would follow the six-month cycle to be released in November 2027, not November 2026."}

{"answer": "8.2", "explanation": "Symfony releases a new minor version of each major line in November, so 8.2 follows 8.1."}

{"answer": "false", "explanation": "Symfony uses major.minor.patch versioning, so a version like 8.2 is a minor release that is backwards-compatible and introduces new features rather than requiring an application rewrite, which only major (X.0) releases may demand."}

```json ⏎ {"answer": "yes", "explanation": "PHP maintains backward compatibility within the same 8.x major version line, so moving from a minor release like 8.1 to 8.2 adds features and bug fixes without requiring code changes, aside from newly deprecated (warning-only) features."} ⏎ ```

{"answer": "8.99", "explanation": "In Symfony's semantic versioning, the final minor release of the 8.x branch before the 9.0 major release would be 8.99, as minor versions increment up to the highest two-digit number before bumping to the next major version."}

{"answer": "no", "explanation": "Symfony 8.x targets PHP 8.3, and the framework does not tie minor releases so tightly to the newest PHP, so Symfony 8.2 would not require the not-yet-released PHP 8.5."}

```json ⏎ {"answer": "yes", "explanation": "According to Symfony's deprecation policy, deprecations are removed two major versions after they are introduced, so deprecations added in the 8.x branch are removed in Symfony 10.0, meaning they will not be removed before 9.0."} ⏎ ```

{"answer": "no", "explanation": "In Twig, the {{ }} syntax only outputs evaluated expressions and does not allow running arbitrary PHP code unless you explicitly register a custom extension."}

{"answer": "yes", "explanation": "Twig automatically escapes output variables based on the current context (e.g., HTML, JS) by default, which is a core security feature of the template engine."}

{"answer": "yes", "explanation": "The Twig |e (or |escape) filter escapes special HTML characters by default to make strings safe for HTML output."}

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

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

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

{"answer": "false", "explanation": "Twig provides the set tag which allows you to declare and assign variables directly inside a template, so values don't only come from the controller."}

{"answer": "dump", "explanation": "The Twig dump() function outputs the debug structure of a variable (array or object), similar to PHP's var_dump() but designed for Twig templates."}

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JavaScript library providing ready-made UI components like navbars, modals, and carousels, whereas an SPA framework (like React or Vue) handles client-side routing and dynamic view rendering."}

{"answer": ".container", "explanation": "The Bootstrap .container class provides a responsive layout with fixed max-widths that change at each breakpoint, unlike .container-fluid which is always full width."}

{"answer": "false", "explanation": "Bootstrap's grid is built on CSS Flexbox (in Bootstrap 4/5) and splits a row into 12 columns, not 16 columns and not floats."}

```json ⏎ {"answer": "yes", "explanation": "Bootstrap 5 defines five named breakpoints (sm, md, lg, xl, xxl) used as infixes in responsive utility class names."} ⏎ ```

{"answer": "yes", "explanation": "Bootstrap generates its spacing utility classes from the $spacer variable, so each numeric value in the class name maps to a multiple or fraction of $spacer."}

{"answer": "data-bs-toggle", "explanation": "The `data-bs-toggle` attribute enables interactive components like dropdowns, modals, and collapses in Bootstrap 5."}

```json ⏎ {"answer": "yes", "explanation": "Bootstrap 5 removed its jQuery dependency entirely, with all components (like modals, tooltips, and carousels) rewritten in plain vanilla JavaScript."} ⏎ ```

{"answer": "no", "explanation": "In Bootstrap 5.3+, dark mode is enabled by adding the `data-bs-theme=\"dark\"` attribute to the root element, not a `.dark` class."}

{"answer": "no", "explanation": "Doctrine ORM does not create tables automatically at runtime; developers must explicitly generate the schema using the schema tool (e.g., `doctrine:schema:create`), typically as part of deployment."}

{"answer": "persist()", "explanation": "The persist() method registers a new entity as managed and defers the actual INSERT SQL until flush() is invoked, unlike merge() which handles detached entities."}

{"answer": "no", "explanation": "The EntityManager::merge() method was deprecated in Doctrine ORM 2.14 and removed entirely in ORM 3.0, so it no longer exists in ORM 3."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is an abstraction layer that lets you write queries using entity names and their property/field names rather than database tables and columns."}

```json ⏎ {"answer": "null", "explanation": "In Doctrine ORM, the repository's find() method returns null when no entity matches the given identifier."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "DoctrineBundle does not automatically call flush(); you must explicitly invoke $em->flush() (or use a subscriber/listener) to persist changes."} ⏎ ```

{"answer": "yes", "explanation": "In Doctrine ORM, once an entity is managed, the Unit of Work tracks property changes through its change tracking mechanism, so flush() detects and persists them without needing an explicit persist()."}

{"answer": "no", "explanation": "In Doctrine ORM, remove() only marks an entity as deleted in the Unit of Work, but the actual SQL DELETE is executed only when flush() is called."}

{"answer": "no", "explanation": "PostgreSQL's MVCC specifically allows readers and writers to execute concurrently without blocking each other, which is one of its primary advantages."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command displays a query's execution plan (how the database engine will process it) without actually running the query."}

{"answer": "no", "explanation": "SERIAL and GENERATED AS IDENTITY are distinct mechanisms: SERIAL is a sequence-backed pseudo-type with its own default-value behavior, while AS IDENTITY follows the SQL standard with explicit identity column semantics and constraints."}

{"answer": "no", "explanation": "In PostgreSQL, NULL values are treated as distinct, so a UNIQUE constraint permits multiple rows containing NULL, not just one."}

{"answer": "STRING_AGG", "explanation": "STRING_AGG is the PostgreSQL aggregate function that concatenates a set of string values using a specified separator argument."}

{"answer": "no", "explanation": "Plain VACUUM reclaims space from dead tuples for reuse within the table but does not return it to the operating system; only VACUUM FULL returns space to the OS."}

{"answer": "PARTITION BY", "explanation": "In a SQL window function, the PARTITION BY clause within the OVER clause divides rows into groups (partitions) over which the window function is computed."}

{"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 runs in autocommit mode, so each standalone SQL statement is automatically wrapped in its own implicit transaction."}

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

{"answer": "yes", "explanation": "Indexes accelerate UPDATE and DELETE operations as well, since a WHERE clause on an indexed column lets the database locate matching rows via the index instead of scanning the entire table."}

{"answer": "yes", "explanation": "PostgreSQL's SAVEPOINT lets you mark a point within a transaction and use ROLLBACK TO SAVEPOINT to undo only the statements after that point while keeping the rest of the transaction."}

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

{"answer": "pgvector", "explanation": "pgvector is the PostgreSQL extension that adds vector data types and indexing (such as IVF, HNSW) for vector similarity search and embedding-based retrieval."}

{"answer": "yes", "explanation": "A partial index is only built over the subset of rows that satisfy the WHERE condition specified in the CREATE INDEX statement."}

{"answer": "no", "explanation": "PostgreSQL's SERIALIZABLE isolation level is implemented via Serializable Snapshot Isolation (SSI), which detects serialization conflicts and raises errors rather than locking the rows it reads."}

{"answer": "yes", "explanation": "HTTP status 201 Created indicates the request succeeded and a new resource was created on the server."}

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

{"answer": "yes", "explanation": "The DELETE method is idempotent because deleting an existing resource removes it, and any subsequent DELETE requests leave the resource in the same (deleted) state, producing the same outcome."}

{"answer": "no", "explanation": "The Access-Control-Allow-Origin header is sent by the server, not the client, to indicate which origins are permitted to access its resources via CORS."}

{"answer": "yes", "explanation": "HTTP status 429 Too Many Requests is the standard response indicating a client has exceeded the rate limit for an API or service."}

{"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 entity sent in the request or response body."}

```json ⏎ {"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not required to be idempotent, whereas PUT is defined as idempotent."} ⏎ ```

{"answer": "no", "explanation": "Using == for hash comparison can expose timing attacks and PHP type-juggling vulnerabilities (e.g., hashes starting with 0e), so a constant-time comparison like hash_equals() is required."}

{"answer": "yes", "explanation": "A CSRF token is generated server-side, stored in the user's session, embedded in forms, and validated server-side on unsafe requests to ensure the request originated from a legitimate source."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is what enables and defines a website's CSP to control which resources the browser is allowed to load."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework that grants delegated access to resources, not an authentication protocol, and access tokens authorize access rather than identify the user (that role belongs to OpenID Connect)."}

```json ⏎ {"answer": "no", "explanation": "XSS is prevented by encoding output at the point of rendering, not by validating input before storage, because the vulnerability occurs when data is reflected back to the browser without proper encoding."} ⏎ ```

{"answer": "authorization_code", "explanation": "In the OAuth 2.0 authorization code flow, the authorization server redirects the user agent back to the client's redirect_uri containing an authorization_code parameter, which the client then exchanges for an access token at the token endpoint."}

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

{"answer": "no", "explanation": "Password salts do not need to be secret; they are typically stored in plaintext alongside the hash, and security comes from their uniqueness per password rather than secrecy."}

{"answer": "false", "explanation": "PHPUnit's test runner and its assertion/framework features require test classes to extend PHPUnit\Framework\TestCase, so a class that does not extend it will not be properly run as a test."}

{"answer": "no", "explanation": "In PHPUnit, setUp() is called before EACH test method, not once before all tests; setUpBeforeClass() runs once before all tests of the class."}

{"answer": "false", "explanation": "A data provider supplies multiple sets of arguments, allowing a single test to run repeatedly with each data set, not just one."}

{"answer": "expectException", "explanation": "The expectException() method declares an expectation that an exception of a given class is thrown during the test."}

{"answer": "false", "explanation": "The statement is backwards: a stub provides return values, while a mock verifies which methods were called."}

{"answer": "yes", "explanation": "PHPUnit 10+ introduced the #[DataProvider] attribute as the modern, non-deprecated way to attach data providers, while the @dataProvider doc-comment annotation is deprecated."}

```json ⏎ {"answer": "no", "explanation": "PHPUnit supports test dependencies through the @depends annotation (or #[Depends] attribute), which allows one test to depend on the result of another."} ⏎ ```

{"answer": "--randomize-order", "explanation": "The --randomize-order option randomizes the order in which PHPUnit executes test cases."}

{"answer": "3-3", "explanation": "intdiv truncates toward zero, so intdiv(7,2)=3 and intdiv(-7,2)=-3, concatenated to '3-3'."}

{"answer": "-9", "explanation": "In PHP, the exponentiation operator `**` binds more tightly than unary minus, so `-3 ** 2` parses as `-(3 ** 2)` = `-(9)` = `-9`."}

```json ⏎ {"answer": "true", "explanation": "Both '1e1' (scientific notation for 10) and '10' are numeric strings, so PHP compares them numerically (10 == 10), making the comparison true."} ⏎ ```

```json ⏎ {"answer": "other", "explanation": "The string 'a' is non-numeric, so PHP compares it against '0' as strings (0 becomes '0'), which are not equal, causing the switch to fall through to the default case."} ⏎ ```

{"answer": "2c", "explanation": "When given an associative array, strtr() translates the longest matching substring first, so 'ab' becomes '2' before 'a' is considered, leaving 'c' unchanged."}

{"answer": "[hello]", "explanation": "The negative offset -10 is beyond the string length (5), so PHP starts from the beginning and returns the full string 'hello', giving '[hello]'."}

{"answer": "k,n,m", "explanation": "The array + operator keeps the left operand's keys with precedence, so $a + $b yields ['k'=>1, 'n'=>2, 'm'=>3], and array_keys plus implode gives 'k,n,m'."}

{"answer": "yxz", "explanation": "usort sorts the sub-arrays by their third element (values 1, 2, 2), placing [2,'y',1] first and keeping [1,'x',2] before [3,'z',2] due to stable sort, then array_column extracts the second elements ['y','x','z'] which implode to \"yxz\"."}

```json ⏎ {"answer": "4", "explanation": "The spread operator with named keys maps b=1 to parameter $b and a=5 to parameter $a, so f returns 5 - 1 = 4."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "`$p->g(...)` creates a partial application (Closure) in PHP 8.4 that binds the method to the object instance, so the object stays alive even after `$p = null`, and calling `$f()` returns the private value 3."} ⏎ ```

{"answer": "B", "explanation": "The `static::class` uses late static binding, so `who()` called on a `B` instance returns `B"}

```json ⏎ {"answer": "", "explanation": "PHP has no property-hook feature, so the `set { ... }` syntax after the property declaration is a parse error and the script never runs (nothing is output)."} ⏎ ```

{"answer": "BA", "explanation": "TB::f insteadof TA makes TC::f return 'B', and TA::f as g aliases the excluded method so TC::g returns 'A', giving the concatenated string \"BA\"."}

{"answer": "0", "explanation": "In PHP, each class using a trait gets its own independent copy of the trait's static property, so CX::$n and CY::$n are separate variables."}

```json ⏎ {"answer": "2", "explanation": "In PHP, a return statement in the finally block overrides the return value from the try block, so f() returns 2."} ⏎ ```

{"answer": "second", "explanation": "The RuntimeException thrown in the inner try is suppressed when the finally block throws a new LogicException, which then propagates to the outer catch and echoes 'second'."}

{"answer": "App\\Foo|Baz", "explanation": "`Baz::class` resolves the imported `App\\Foo` alias to its fully-qualified name `App\\Foo`, while `\\Baz::class` refers to the (non-existent) global class and `::class` simply returns its unqualified name `Baz` without requiring the class to exist."}

{"answer": "yesyes", "explanation": "The unqualified class_exists('Foo') resolves to Ns\\Foo (the current namespace), which exists, and the fully-qualified Ns\\Foo also exists, so both checks return yes."}

```json ⏎ {"answer": "1,2,99", "explanation": "The foreach loop with & creates a reference to the last array element, so $v = 99 overwrites $a[2] to 99 before the implode."} ⏎ ```

{"answer": "3", "explanation": "Since class B does not override inc(), both $a->inc() and $b->inc() call the same inherited method, so the static $n variable is shared across all calls, giving 1, 2, then 3."}

{"answer": "11", "explanation": "Calling send(10) resumes the generator, assigning 10 to $x, so the return statement evaluates to 10 + 1 = 11, which getReturn() then yields."}

{"answer": "1,2,ok", "explanation": "`yield from inner()` yields 1 and 2, and its return value 'ok' is assigned to $r, which is then yielded by outer, producing the array [1, 2, 'ok']."}

{"answer": "noyes", "explanation": "The first password_needs_rehash compares with cost 4 (matching), returning false → 'no', while the second compares with cost 5 (different), returning true → 'yes', giving output 'noyes'."}

```json ⏎ {"answer": "strict-out", "explanation": "PHP 8.4 deprecated E_STRICT (bit 2048) and removed it from E_ALL, so in PHP 8.5 E_ALL & 2048 equals 0, making the ternary evaluate to 'strict-out'."} ⏎ ```

{"answer": "mapped", "explanation": "Symfony converts the HTTP_X_TOKEN server parameter into the X-Token request header, so get('X-Token') returns 'abc'."}

{"answer": "BCA", "explanation": "Listeners run in descending priority order, so B (priority 10), then C (priority 5), then A (priority 0), producing the string BCA."}

{"answer": "same", "explanation": "Both find() calls use the same EntityManager, which returns the already-migrated entity from its identity map rather than creating a new object."}

{"answer": "0", "explanation": "Because persist() then remove() are called in the same UnitOfWork before flush, the remove() call cancels the pending insert (cancelAdd), so flush() performs no insert or delete and the users table stays empty."}

{"answer": "1", "explanation": "count(x) ignores NULL values, so only the single non-NULL row (x=1) is counted."}

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

{"answer": "M1M2", "explanation": "The bus processes middlewares in order, so M1 echoes first (outermost) and M2 echoes second before the actual handler runs."}

{"answer": "11", "explanation": "The HandleMessageMiddleware iterates over all handlers registered for the Ping message and executes each in turn, so $n becomes 1 from $d1 then 11 from $d2."}

```json ⏎ {"answer": "1", "explanation": "The first insert adds the value 1, and the second insert conflicts with the unique index and is ignored due to ON CONFLICT DO NOTHING, leaving one row."} ⏎ ```

{"answer": "2", "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, the duplicate-value check is postponed until the end of the transaction, and since the transaction is never committed or rolled back, both INSERTs remain valid and count(*) returns 2."}

{"answer": "6", "explanation": "PHPUnit's --filter option is an unanchored regex, so `test_sum` matches both `test_sum` and `test_sum_abs`, each running its 3 data sets (3+3=6), while `test_other` does not match."}

{"answer": "2,1", "explanation": "The data provider supplies two test cases (x=1 and x=-1), so 2 tests run, and only the x=-1 case fails the assertTrue."}

{"answer": "POST", "explanation": "The `-d` (or `--data`) option in curl sends data in an HTTP POST request by default, using the application/x-www-form-urlencoded content type."}

{"answer": "GET", "explanation": "The -G flag makes curl append the -d data to the URL as a query string and use the HTTP GET method instead of the default POST."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, an unknown or non-existent client_id results in an \"invalid_client\" error indicating the client authentication failed or the client is not registered."}

{"answer": "fragment (hash) portion", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access token is returned in the URI fragment (after the #) rather than the query string to prevent it from being sent to the server or logged."}

```json ⏎ {"answer": "6", "explanation": "The `default` filter returns `2` because `false` is considered empty/falsy, so `false|default(2)` yields `2`, and `2 * 3` equals `6`."} ⏎ ```

{"answer": "Twig\\Error\\RuntimeError", "explanation": "The `~` operator has higher precedence than `+`, so the expression parses as `('a' ~ 1) + 2`, which becomes `'a1' + 2`; since `'a1'` is not numeric, Twig's addition operator throws a RuntimeError."}

{"answer": "1", "explanation": "The validator traverses the input array `['']` and applies the NotBlank constraint to the single element at index 0 (an empty string), which fails validation, producing exactly one violation."}

```json ⏎ {"answer": "Symfony\\Component\\Form\\UnexpectedCallException", "explanation": "Calling isValid() on a form that has never been submitted with data throws a Symfony\\Component\\Form\\UnexpectedCallException, which is caught and echoed via get_class()."} ⏎ ```

{"answer": "same", "explanation": "ContainerBuilder::get() inherits Container::get(), which simply returns the Definition object stored in $this->services['a'] without instantiating it, so both calls return the identical object."}

```json ⏎ {"answer": "hi Bob!", "explanation": "During compile(), Symfony's parameter bag resolves the nested placeholders ('%name%' becomes 'Bob', '%greeting%' becomes 'hi Bob'), so getParameter('message') returns 'hi Bob!'."} ⏎ ```

{"answer": "960px", "explanation": "In Bootstrap 5.3, the .container reaches its 'lg' breakpoint (≥992px) width of 960px."}

{"answer": "text-danger", "explanation": "Both .text-danger and .text-primary set the same color property with equal specificity, so the CSS rule that appears later in Bootstrap 5.3's source order (text-danger) wins."}

{"answer": "2", "explanation": "The OrderService is in the Domain layer, which may only depend on Domain (Domain → Domain only), but it depends on Application\\PlaceOrder and Infrastructure\\Db, each of which constitutes a separate violation."}

```json ⏎ {"answer": "2", "explanation": "The Domain layer rule (Domain → Domain only) is violated by two layer dependencies: Domain → Application (PlaceOrder) and Domain → Infrastructure (Db and Logger), counted as two deptrac violations."} ⏎ ```

{"answer": "10,15", "explanation": "The first Money has amount 10, and add() creates a new Money with amount 10+5=15, so it echoes 10 and 15 separated by a comma."}

```json ⏎ {"answer": "1", "explanation": "The remove() method throws a DomainException because only one item exists, the exception is caught by the empty try/catch, and the item was never unset, so count() returns 1."} ⏎ ```

{"answer": "hi", "explanation": "The code creates a new instance of class C, calls the hi() method which returns the string 'hi', and echoes it, producing the output 'hi'."}

{"answer": "yesno", "explanation": "newLazyGhost creates an uninitialized lazy ghost so the first check prints 'yes', and accessing $o->v triggers the initializer making the object initialized so the second check prints 'no'."}

```json ⏎ {"answer": "no", "explanation": "The Guard authentication system, including AbstractGuardAuthenticator, was removed in Symfony 6.0, so the class does not exist in Symfony 8.1."} ⏎ ```

{"answer": "noyes", "explanation": "AnnotationClassLoader was deprecated in Symfony 5.1 and removed by 6.0 so it no longer exists (outputs 'no'), while AttributeClassLoader remains as the attribute-based loader (outputs 'yes')."}