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

{"answer": "no", "explanation": "In PHP, single-quoted strings are treated almost literally and do not interpolate variables or process most escape sequences, while double-quoted strings undergo variable interpolation and escape sequence processing."}

{"answer": "yes", "explanation": "The null coalescing operator (??) follows isset semantics and returns the left operand if it exists and is not null, otherwise the right operand, without raising undefined variable warnings."}

{"answer": "ab", "explanation": "PHP's echo statement accepts multiple comma-separated arguments and outputs them consecutively, so 'a' and 'b' print as 'ab'."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, print is a language construct that returns the integer value 1 on success and can be used within an expression, unlike echo."} ⏎ ```

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

{"answer": "no", "explanation": "In PHP the string concatenation operator (.) actually has HIGHER precedence than addition and subtraction, so expressions like '1 . 2 + 3' evaluate as (1 . 2) + 3, not 1 . (2 + 3)."}

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

```json ⏎ {"answer": "3", "explanation": "The concatenation operator '.' has higher precedence than '+', so 'sum: ' . 2 first evaluates to 'sum: 2', then 'sum: 2' + 3 converts the non-numeric string to 0, giving 3."} ⏎ ```

{"answer": "no", "explanation": "With strict comparison (===), PHP arrays are only equal if they contain the same key/value pairs in the same order and of the same types, so order does matter."}

{"answer": "no", "explanation": "The statement is false because == is a loose (not strict) comparison, and 0 == false actually returns true since 0 evaluates to false under loose comparison."}

```json ⏎ {"answer": "yes", "explanation": "In PHP 8, loose comparison converts the non-numeric string \"abc\" to 0, so the comparison becomes 0 == 0, which evaluates to true."} ⏎ ```

{"answer": "yes", "explanation": "In PHP loose comparison, null == 0, null == \"\", and null == false all evaluate to true, so null is loosely equal to all three simultaneously."}

{"answer": "42", "explanation": "PHP converts a string to an integer by parsing the leading numeric portion, so '42abc' becomes 42."}

```json ⏎ {"answer": "'55'", "explanation": "In JavaScript, when a string is added to a number, the number is coerced to a string and string concatenation occurs, so '5' + 5 results in '55'."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, casting the boolean false to a string yields the string \"0\", so the statement is true."}

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

{"answer": "no", "explanation": "strrev() reverses bytes rather than characters, so multibyte UTF-8 characters get corrupted instead of properly reversed."}

{"answer": "yes", "explanation": "str_contains() checks if a string contains a substring and returns the boolean value true when found, so it does return true."}

```json ⏎ {"answer": "no", "explanation": "str_pad() can pad on the left, right, or both sides of a string depending on the pad_type parameter (STR_PAD_LEFT, STR_PAD_RIGHT, or STR_PAD_BOTH)."} ⏎ ```

{"answer": "false", "explanation": "trim() by default strips all whitespace characters (space, tab, newline, carriage return, vertical tab, form feed), not just spaces."}

```json ⏎ {"answer": "6", "explanation": "strlen counts bytes, and 'héllo' contains 5 characters where 'é' takes 2 bytes in UTF-8, totaling 6 bytes."} ⏎ ```

{"answer": "def", "explanation": "substr with a negative offset counts from the end of the string, so starting at -3 returns the last 3 characters."}

{"answer": "no", "explanation": "PHP strings are immutable, so ucfirst() returns a new modified string rather than altering the original in place."}

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

{"answer": "false", "explanation": "The sort() function sorts an array in ascending order but reindexes the keys numerically, thereby destroying the original key-to-value association; asort() is used to preserve keys."}

{"answer": "yes", "explanation": "In PHP, string keys that represent valid integers are automatically converted to integer keys in arrays."}

{"answer": "no", "explanation": "The in_array() function uses loose comparison (==) by default; you must pass TRUE as the third argument to enable strict comparison (===)."}

{"answer": "yes", "explanation": "When no callback is provided, array_filter() removes all elements that evaluate to a falsy value (false, 0, \"0\", null, \"\", and empty arrays)."}

{"answer": "no", "explanation": "By default array_slice() reindexes numeric keys starting from 0, only preserving original keys when the optional $preserve_keys parameter is set to true."}

{"answer": "[20, 30]", "explanation": "array_slice extracts a portion starting at offset 1 (element 20) and returns the next 2 elements, which are 20 and 30."}

{"answer": "1", "explanation": "The + operator unites arrays with left-hand values taking precedence, so key 'a' keeps its value 1 and key 'b' is dropped, leaving a single-element array."}

```json ⏎ {"answer": "yes", "explanation": "PHP 8.1 introduced support for spreading associative arrays, allowing the spread operator to preserve string keys instead of reindexing them numerically."} ⏎ ```

{"answer": "no", "explanation": "Named arguments CAN be combined with argument unpacking in a single call, as long as no parameter name is specified more than once across the unpacked array and the named arguments."}

{"answer": "false", "explanation": "In PHP, an anonymous function does not automatically access outer scope variables; you must explicitly import them using the `use` keyword."}

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

{"answer": "no", "explanation": "Arrow functions in PHP (fn) only support a single expression body with implicit return and cannot use curly braces to contain multiple statements."}

{"answer": "no", "explanation": "In PHP, arrow functions automatically capture outer variables by value at definition time, not by reference or lazily at use time."}

{"answer": "yes", "explanation": "A static closure does not have an object context, so it cannot access $this by design in PHP."}

{"answer": "5", "explanation": "The closure captures $x by value at definition time, so it returns the captured value 5, unaffected by the later reassignment to 7."}

{"answer": "yes", "explanation": "In weak (non-strict) typing mode, PHP coerces the string \"5\" to the integer 5 when passed to an int parameter."}

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

{"answer": "final", "explanation": "The final keyword in PHP prevents a method from being overridden in subclasses."}

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

{"answer": "no", "explanation": "Private properties are only accessible within the class that defines them, not in subclasses; protected or public visibility would be required for subclass access."}

{"answer": "@anonymous", "explanation": "An anonymous class in PHP gets an auto-generated name in the form `@anonymous\\0<path>:<line>`, and get_class() returns everything before the NUL byte as `@anonymous`."}

{"answer": "yes", "explanation": "Private methods are not inherited and thus not part of the inheritance contract, so a child class may redeclare a method with the same name and any visibility without conflict."}

{"answer": "no", "explanation": "__get() is invoked not only for non-existent properties but also for properties that are inaccessible (private/protected) in the current access context."}

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP 8.1+ throws an Error (specifically a plain Error class, not an Exception subclass)."}

{"answer": "yes", "explanation": "Since PHP 7.1, interfaces can declare constants with const declarations, which are implicitly public and static."}

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

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces can declare and implement static methods, allowing concrete classes to provide their own static implementations."}

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

{"answer": "yes", "explanation": "Since PHP 8.0, interface methods can have default implementations, similar to trait methods."}

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared with public, protected, or private visibility, so there is no restriction requiring abstract methods to be public."}

```json ⏎ {"answer": "3", "explanation": "Enum::cases() is a static method that returns an array containing all of the enum's declared cases, so Foo with cases A, B, and C returns an array of 3 elements."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "PHP traits can indeed declare constants, properties, and methods, which are then imported into the using class as if they were defined there."} ⏎ ```

{"answer": "yes", "explanation": "In PHP 7 and later, Throwable is the base interface that both Exception and Error extend, making it their common ancestor."}

{"answer": "no", "explanation": "TypeError inherits from Error, not Exception, so a catch (Exception $e) block will not catch it."}

{"answer": "no", "explanation": "The @ operator only suppresses PHP errors (like warnings and notices), not exceptions, which are handled through try/catch blocks."}

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError because dividing an integer by zero is not allowed in PHP."}

{"answer": "no", "explanation": "The finally block always runs regardless of whether an exception was thrown or caught, or whether it propagated uncaught."}

{"answer": "no", "explanation": "An exception thrown inside a finally block overrides any exception or return value from the try block, so it definitely affects the result rather than having no effect."}

{"answer": "yes", "explanation": "In PHP, converting an object to a boolean returns true unless the object's __toString() method returns an empty string; since Exception::__toString() returns the non-empty message 'x', the cast yields true."}

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

{"answer": "no", "explanation": "The `use` statement only imports an alias for a namespace at compile time; the class file is loaded later by PHP's autoloader when the class is actually referenced."}

```json ⏎ {"answer": "function", "explanation": "In PHP, the 'use' keyword is followed by 'function' to import a function and 'const' to import a constant, while classes are imported without any prefix."} ⏎ ```

{"answer": "Controller/Api/UserController.php", "explanation": "Under PSR-4, the App\\ namespace maps to src/, so App\\Controller\\Api\\UserController corresponds to the file src/Controller/Api/UserController.php, which is Controller/Api/UserController.php relative to src/."}

{"answer": "yes", "explanation": "Composer's vendor/autoload.php loads generated classmap and PSR-4 loader files that register their callbacks through spl_autoload_register()."}

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

{"answer": "no", "explanation": "Unqualified class names in `new` are resolved relative to the current namespace, not the global root; only names with a leading backslash are resolved from the global root."}

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

{"answer": "yes", "explanation": "In PHP, the use statement for namespaces can be written inside a function or method scope, where it applies only to that local scope rather than the entire file."}

{"answer": "yes", "explanation": "In PHP, arrays use value semantics, so assigning an array to another variable creates a copy (via copy-on-write) rather than a reference to the original."}

{"answer": "2", "explanation": "PHP uses copy-on-write semantics, so modifying $b after $b = $a does not affect $a, which remains [1, 2]."}

{"answer": "yes", "explanation": "In PHP, user-defined variables at global scope are not accessible inside a function's local scope unless declared with global, accessed via $GLOBALS, or passed as parameters, though superglobals are an exception."}

{"answer": "no", "explanation": "unset($GLOBALS['x']) removes the global variable x completely from the global scope, not merely for the current function, because $GLOBALS holds references to global variables."}

```json ⏎ {"answer": "6", "explanation": "The function takes $x by reference, so $x++ modifies $n directly, outputting 6."} ⏎ ```

{"answer": "no", "explanation": "In PHP, a foreach by value iterates over a copy of the array, so modifications made inside the loop are not visible during that same pass."}

{"answer": "no", "explanation": "A static property belongs to the class itself, not to individual instances, so changes to it are visible across all instances."}

{"answer": "no", "explanation": "In PHP, array keys can only be integers or strings, so a boolean key like `true` is coerced to the integer 1, not stored as a boolean."}

{"answer": "yes", "explanation": "In PHP, a generator can return a value using return $value, and that value can be retrieved via $gen->getReturn() once the generator is finished, so the statement is true."}

```json ⏎ {"answer": "yes", "explanation": "In PHP 7.1+, a generator that has been fully drained supports rewind(), which resets its internal state so it can be traversed again from the start."} ⏎ ```

{"answer": "yes", "explanation": "The `yield from` construct in PHP delegates traversal to another generator, Traversable object, or array, yielding its values directly."}

{"answer": "Generator", "explanation": "Because the function contains a yield keyword it becomes a generator function, and calling it returns a Generator object whose class name get_class() reports as \"Generator\"."}

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

{"answer": "no", "explanation": "SplStack implements a LIFO (Last In First Out) stack, while SplQueue implements a FIFO queue."}

{"answer": "yes", "explanation": "ArrayIterator is a PHP SPL class that wraps an array and lets you traverse and access it using the Iterator interface (and related interfaces like ArrayAccess and SeekableIterator)."}

{"answer": "false", "explanation": "ArrayObject implements Traversable and Iterator, so it can indeed be traversed with foreach."}

{"answer": "yes", "explanation": "password_hash() automatically generates a cryptographically secure random salt when none is supplied, so providing one separately is unnecessary (and discouraged)."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT uses bcrypt by default (and argon2 variants if available in PHP 8.1+), not the cryptographically broken md5 algorithm."}

{"answer": "yes", "explanation": "password_verify returns true when the plaintext matches the hashed password, and since both use 'secret', they match."}

{"answer": "no", "explanation": "strip_tags() only removes HTML and PHP tags from a string to help prevent XSS attacks; it does nothing to prevent SQL injection, which requires parameterized queries or proper escaping."}

{"answer": "yes", "explanation": "session_regenerate_id() generates a new session ID, which is a standard defense against session fixation attacks, especially important after a privilege change like login."}

{"answer": "php_sapi_name()", "explanation": "The php_sapi_name() function returns the name of the Server Application Programming Interface (SAPI) that PHP is running against, such as 'cli' for the command line interface."}

{"answer": "yes", "explanation": "session_destroy() only removes the session data stored on the server side, leaving the client-side session cookie intact."}

{"answer": "no", "explanation": "The $_SESSION array is empty until session_start() is called, which initializes the session and populates the array with stored session data."}

{"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3 along with array_find_key, array_some, and array_every."}

{"answer": "yes", "explanation": "Property hooks were indeed introduced in PHP 8.4, allowing get/set logic to be defined directly within the property declaration."}

{"answer": "no", "explanation": "Asymmetric visibility (public private(set) property) was introduced in PHP 8.2, not 8.4."}

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

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

{"answer": "8.4", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) was introduced in PHP 8.4."}

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

{"answer": "8.4", "explanation": "The RFC Partial Function Application v2 was adopted for PHP 8.4, introducing the `partial()` function and `\\Closure::from_partial()`."}

{"answer": "8.4", "explanation": "The clamp() function was implemented via the clamp_v2 RFC and released in PHP 8.4."}

{"answer": "no", "explanation": "The Context Managers RFC proposal (including its revised v2 version) was not adopted into PHP, as it faced significant opposition and never reached acceptance."}

{"answer": "yes", "explanation": "The PHP RFC for Bound-Erased Generic Types was indeed declined in 2026, as the maintainers determined the approach did not adequately resolve type-safety concerns."}

{"answer": "no", "explanation": "As of the stated date, the RFC to make ZTS (thread-safe/multithreading) mode the default build in PHP has not been accepted; PHP still ships with non-ZTS (TSRM-disabled) as the default build."}

{"answer": "yes", "explanation": "PHP does not yet have native generics/parameterized types as of version 8.5; they were deferred to a later release while PHPDoc-based @template support remains the only generic-like mechanism."}

{"answer": "yes", "explanation": "PHP follows an annual release cycle, with PHP 8.5 GA in November 2025 and PHP 8.6 GA scheduled around November 2026, so as of 2026-11-07, 8.5 would indeed be the latest stable release and 8.6 not yet GA."}

{"answer": "yes", "explanation": "PHP 6 was cancelled during development, and PHP 5.6 was directly followed by PHP 7.0."}

{"answer": "no", "explanation": "The RFC adding the #[\\Deprecated] attribute was voted down (rejected) in the February 2024 PHP vote because it did not reach the required 2/3 majority."}

{"answer": "yes", "explanation": "In clean/onion architecture, the dependency rule requires that inner layers remain independent of outer ones and all dependencies point inward toward the center."}

{"answer": "yes", "explanation": "Domain entities in clean/DDD-style architecture are meant to be pure and framework-agnostic, depending only on the language and standard library so they stay independent of Doctrine, Symfony, and other infrastructure concerns."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the framework/presentation layer, not the business-logic layer; business logic lives in use cases and domain objects, while controllers merely call them."}

{"answer": "The domain (domain entities and business rules)", "explanation": "In onion architecture, the innermost layer contains the domain model, which holds the core business rules and entities, with all other layers (domain/application services, infrastructure, interfaces) wrapping around it."}

```json ⏎ {"answer": "yes", "explanation": "Deptrac is a layer dependency analyzer that inspects code structure and fails the build when a forbidden cross-layer dependency is detected."} ⏎ ```

{"answer": "no", "explanation": "Use cases should be decoupled from infrastructure, so they must accept plain DTOs/primitives rather than framework objects like HTTP requests or EntityManager, which should be injected as dependencies instead."}

{"answer": "Repository", "explanation": "A Repository is the design component in Domain-Driven Design that mediates between the domain and data mapping layers, providing a collection of aggregates/entities while hiding the storage mechanism behind an interface."}

{"answer": "yes", "explanation": "In clean architecture the database lives in the outer infrastructure layer behind interfaces, so switching databases only changes that outer adapter while the domain and use cases remain untouched."}

{"answer": "no", "explanation": "An aggregate in DDD is a cluster of domain objects treated as a unit for change purposes, not a database table, and it can span multiple tables."}

{"answer": "yes", "explanation": "A Value Object is immutable and compared by the values of its fields (structural/value equality) rather than by reference identity, which is the defining characteristic of value objects in domain-driven design."}

```json ⏎ {"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, an aggregate root is the single external entry point of an aggregate, through which all changes to the aggregate's members must occur, ensuring consistency and integrity."} ⏎ ```

{"answer": "yes", "explanation": "In DDD, repositories are created for each aggregate root because aggregates are treated as a single unit of identity and consistency, so individual entities within the aggregate are not exposed through their own repositories."}

{"answer": "yes", "explanation": "Ubiquitous language is indeed the shared, consistent vocabulary developed collaboratively between developers and domain experts to describe the domain model."}

{"answer": "the standard model", "explanation": "In model theory, the standard model is the intended interpretation within which a language and its symbols are consistent, whereas the same symbols take on different meanings in non-standard or other models."}

{"answer": "no", "explanation": "DDD actually recommends rich domain models where objects encapsulate both data and behavior, as the anemic domain model (data with logic in services) is widely criticized as an anti-pattern by Eric Evans and Martin Fowler."}

{"answer": "yes", "explanation": "In Domain-Driven Design, each bounded context has its own model, so the same concept (e.g., 'Customer' or 'Product') is represented by different classes in different contexts to fit each context's specific needs."}

{"answer": "yes", "explanation": "Symfony's compiled DI container instantiates services on-demand the first time they are requested rather than eagerly creating all services at container build time."}

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

{"answer": "no", "explanation": "Symfony's autowiring and autoconfigure features automatically wire and declare most services, so you don't have to manually declare every service in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes and caches them to avoid recompilation on subsequent requests."}

{"answer": "yes", "explanation": "In the dev environment Symfony compiles and caches the DI container to var/cache/dev, and only rebuilds it when the modification times of tracked files change, using an efficiency mechanism rather than recompiling on every request."}

{"answer": "APP_ENV", "explanation": "Symfony reads the APP_ENV environment variable to determine whether the kernel runs in dev or prod mode."}

{"answer": "no", "explanation": "In Symfony, controller actions must be public methods; private (or protected) methods cannot be invoked as routing targets."}

{"answer": "no", "explanation": "In Symfony's EventDispatcher, both subscribers and listeners are ordered by their registered priority, so a high-priority listener can be called before a low-priority subscriber; the subscriber interface itself grants no automatic priority."}

{"answer": "yes", "explanation": "In Symfony 6.0 the old 'guard' authentication system was deprecated and removed, leaving the new AuthenticatorInterface-based authenticators as the only supported approach."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute authorizes access by checking a role or permission, returning a 403 Forbidden response when the check fails."}

{"answer": "yes", "explanation": "Voters are indeed Symfony's mechanism for authorizing access to objects or attributes, and isGranted('EDIT', $post) passes a specific object ($post) as the subject to trigger voter evaluation."}

{"answer": "yes", "explanation": "Symfony 7 requires PHP 8.1+ where annotations were dropped and attributes became the sole supported configuration format for constraints."}

{"answer": "yes", "explanation": "In Symfony, CSRF protection is enabled by default for forms (the csrf_protection option defaults to true), and the token is validated automatically when the form is submitted."}

{"answer": "yes", "explanation": "Symfony always performs server-side form validation when processing a submitted form, regardless of whether client-side HTML5 checks passed, because HTML5 validation can be bypassed."}

{"answer": "make:form", "explanation": "The Symfony MakerBundle's `make:form` command generates a form class (FormType) based on the entity or fields you specify."}

{"answer": "no", "explanation": "Symfony stores only the user identifier in the session, not the password, and passwords are stored as hashes rather than in plain text."}

{"answer": "yes", "explanation": "In Symfony, bundle and topic configurations are stored in config/packages as separate YAML files named after the bundle or feature, such as framework.yaml, doctrine.yaml, and security.yaml."}

{"answer": "yes", "explanation": "This matches the standard convention where the committed .env contains default/development values while the git-ignored .env.local holds sensitive, machine-specific secrets."}

{"answer": "debug:container", "explanation": "The `debug:container` command lists all registered services and their aliases in a Symfony application's dependency injection container."}

{"answer": "no", "explanation": "Once the Symfony container is compiled, it is frozen and parameters become constants, so calling setParameter() at runtime from a controller throws a 'Cannot override parameter following compilation' exception."}

{"answer": "no", "explanation": "In Symfony, services are private (public: false) by default, meaning they cannot be fetched directly from the container and can only be used via dependency injection."}

{"answer": "no", "explanation": "Bundles can operate using built-in default settings, so a config file in config/packages is optional, not mandatory."}

{"answer": "yes", "explanation": "Symfony supports the %env(VAR_NAME)% syntax in services.yaml to inject environment variable values into services at runtime."}

{"answer": "APP_DEBUG", "explanation": "In Symfony, the APP_DEBUG environment variable controls whether debug mode is enabled, which activates the profiler and Twig's debugging capabilities."}

{"answer": "no", "explanation": "In Symfony Messenger, a single message can be handled by multiple handlers, as the message mapping allows one message type to be associated with several handlers (including by message and by method)."}

{"answer": "no", "explanation": "The sync transport processes the message immediately in the current process rather than queuing it for a worker, unlike the async transport."}

{"answer": "messenger:work", "explanation": "The `messenger:work` console command starts the queue worker that processes Messenger queue messages in Laravel's messenger package."}

```json ⏎ {"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy is configured per-transport within the messenger transports configuration."} ⏎ ```

{"answer": "no", "explanation": "By default, Symfony Messenger serializes messages using PHP's native serializer (serialize()), not JSON, which is only available if you explicitly configure the JSON encoder."}

{"answer": "no", "explanation": "Symfony Scheduler executes tasks (commands or closures) on a schedule but is a standalone component that does not dispatch messages through the Messenger component."}

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

{"answer": "yes", "explanation": "In Symfony Messenger, you can register custom middleware in the messenger configuration, and they execute in the defined order relative to the built-in middleware."}

{"answer": "yes", "explanation": "Symfony follows this cadence: LTS (major) releases occur every two years in May, while minor/normal releases are issued roughly every six months, in May and November."}

{"answer": "8.3", "explanation": "Symfony 8, an LTS release, requires a minimum of PHP 8.3 as part of Symfony's policy to support recent PHP versions."}

{"answer": "no", "explanation": "Symfony 7.0 removed support for Doctrine annotations (including routing and validation), requiring developers to use PHP attributes exclusively."}

{"answer": "yes", "explanation": "Symfony's AssetMapper component manages local and external CSS/JS assets without requiring Node.js or webpack, using importmap.php as its central configuration file to track and resolve assets."}

```json ⏎ {"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long Term Support) release, providing 5 years of support (3 years of bug fixes plus 2 years of security fixes), unlike regular non-LTS releases which only get 1 year."} ⏎ ```

{"answer": "no", "explanation": "In Symfony, deprecations introduced in a previous major version are removed in the next major release, so they do not keep working after the upgrade."}

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

{"answer": "symfony/importmap", "explanation": "The Symfony ImportMap feature (provided by the symfony/importmap component) manages JavaScript/CSS assets and imports directly through the browser's native ES module importmap, eliminating the need for Node.js or Webpack."}

{"answer": "no", "explanation": "Symfony 8.0 was scheduled for release in November 2026, so Symfony 8.2 (expected around May 2027) would not yet exist as of 2026-11-07."}

{"answer": "no", "explanation": "Following Symfony's six-month release cycle, version 8.2 is scheduled for May 2028, not November 2026; the November 2026 release would be Symfony 7.4 (LTS)."}

{"answer": "8.2", "explanation": "Symfony's minor versions increment sequentially within the same major version, so 8.2 is the next release after 8.1."}

{"answer": "no", "explanation": "Symfony 8.2 is a minor release within the Symfony 8.x major version series; only the 8.0 release (with an even major version number) is the major release, and minor releases are backward compatible rather than requiring a full rewrite."}

```json ⏎ {"answer": "yes", "explanation": "PHP's official compatibility policy guarantees backward compatibility within a major version line, so upgrading from 8.1 to 8.2 should not require code changes."} ⏎ ```

{"answer": "8.4", "explanation": "In Symfony's versioning scheme, each major (8.x) branch has releases ending in .0, .1, .2, .3, and .4, with 8.4 being the final (LTS) release before the 9.0 major release in November 2029."}

{"answer": "no", "explanation": "Symfony's minimum PHP version typically tracks conservatively (Symfony 8.0 is expected to require PHP 8.3), and it would not jump to requiring the unreleased PHP 8.5 for the 8.2 minor version."}

{"answer": "yes", "explanation": "According to Symfony's deprecation policy, deprecated code introduced in a given major version is scheduled for removal only in a later major version, so deprecations added in the 8.x branch are not removed before Symfony 9.0."}

{"answer": "no", "explanation": "The {{ }} syntax in Twig only evaluates and prints expressions, not execute arbitrary PHP code, which must instead be contained in functions Twig allows."}

{"answer": "yes", "explanation": "Twig enables autoescaping by default, which escapes special HTML characters in printed variables using the appropriate autoescaper (html by default)."}

{"answer": "yes", "explanation": "The Twig |e (escape) filter by default uses the HTML escaping strategy, making it safe for HTML output contexts."}

{"answer": "format_number", "explanation": "The Twig intl-extra component provides the `format_number` filter to format numbers according to a given locale."}

{"answer": "yes", "explanation": "The |raw filter in Twig marks the value as already safe, disabling auto-escaping for it."}

{"answer": "yes", "explanation": "In Twig, {{ }} is used to print output the result of an expression, while {% %} executes tags such as if conditions, for loops, and set assignments."}

```json ⏎ {"answer": "no", "explanation": "Twig lets you declare variables inside a template using the {% set %} tag, so values are not limited to what comes from the controller."} ⏎ ```

{"answer": "dump", "explanation": "The Twig `dump` function outputs the debug information of a variable such as an array or object, similar to PHP's var_dump."}

{"answer": "yes", "explanation": "Bootstrap is a front-end framework providing CSS and JavaScript UI components, not a single-page application framework like React or Angular."}

{"answer": "container", "explanation": "The Bootstrap `.container` class provides a responsive wrapper with fixed max-widths that change per breakpoint."}

{"answer": "no", "explanation": "Bootstrap's grid uses 12 columns (not 16), and Bootstrap 4/5 are built on Flexbox rather than CSS floats."}

{"answer": "yes", "explanation": "Bootstrap 5 defines five named breakpoints with infixes sm, md, lg, xl, and xxl, while the extra-small (xs) breakpoint is the base with no infix."}

{"answer": "yes", "explanation": "Bootstrap spacing utilities like .mt-3 and .px-2 pull values from the spacing scale ($spacers), whose entries are all multiples of the base $spacer variable."}

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, interactive components are activated using the data-bs-toggle attribute (the leading bs- was added to namespace data attributes compared to Bootstrap 4)."}

{"answer": "yes", "explanation": "Bootstrap 5 was rewritten to remove the jQuery dependency, so all its components now run on plain vanilla JavaScript."}

{"answer": "yes", "explanation": "In Bootstrap 5.3+, dark mode is enabled by adding the `.dark` class to a root element, which activates the dark color-scheme CSS variables."}

{"answer": "no", "explanation": "Doctrine ORM does not create tables at runtime; schemas must be explicitly generated using the schema-tool command (e.g., 'doctrine:schema:create')."}

{"answer": "persist()", "explanation": "EntityManager::persist() marks an object as managed without executing SQL; the INSERT is deferred until flush() is called."}

{"answer": "no", "explanation": "In Doctrine ORM 3.0, the EntityManager::merge() method was removed (it was deprecated since ORM 2.5), so it no longer exists to make objects managed."}

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

{"answer": "null", "explanation": "In Doctrine ORM, repository->find() returns null when no entity matches the given identifier."}

{"answer": "no", "explanation": "DoctrineBundle does not automatically call flush(); you must explicitly call $entityManager->flush() to persist changes to the database."}

{"answer": "yes", "explanation": "For an already-managed entity, Doctrine's Unit of Work uses change detection (snapshots) to automatically detect property modifications, so a plain flush() is sufficient without re-calling persist()."}

```json ⏎ {"answer": "no", "explanation": "In Doctrine ORM, remove() only schedules the entity for deletion in the UnitOfWork; the actual SQL DELETE is executed only when flush() is called."} ⏎ ```

{"answer": "false", "explanation": "MVCC allows readers and writers to proceed concurrently without blocking each other, which is its key advantage—writers don't block readers and readers don't block writers."}

```json ⏎ {"answer": "EXPLAIN", "explanation": "The EXPLAIN command displays a query's execution plan showing how the database will process the query without actually running it."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "SERIAL creates a sequence with a default nextval() call and owns it via a dependency, while GENERATED AS IDENTITY implements the SQL-standard identity column mechanism with finer control (ALWAYS vs BY DEFAULT), so they are distinct features, not two names for the same thing."} ⏎ ```

{"answer": "no", "explanation": "PostgreSQL treats NULLs as distinct in UNIQUE constraints, so multiple rows with NULL values are allowed."}

{"answer": "CONCAT_WS", "explanation": "CONCAT_WS (Concatenate With Separator) is the PostgreSQL aggregate/functional that joins strings using a specified separator argument."}

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

{"answer": "PARTITION BY", "explanation": "The PARTITION BY clause divides the result set into groups (partitions) that the window function is computed over."}

{"answer": "no", "explanation": "READ COMMITTED only protects against 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 and committed immediately."}

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

{"answer": "yes", "explanation": "Indexes are used to quickly locate rows matching a WHERE clause, so UPDATE and DELETE operations that search on indexed columns also benefit by avoiding full table scans."}

{"answer": "yes", "explanation": "SAVEPOINT creates a marker within a transaction that allows you to roll back only the statements executed after it, without ending the entire transaction."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE both generates the query plan and actually executes the query to measure real timing and row counts, whereas plain EXPLAIN only shows the plan without executing."}

{"answer": "pgvector", "explanation": "pgvector is an open-source PostgreSQL extension that adds vector data types and index types (like IVFFLAT and HNSW) for similarity search and embedding retrieval."}

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

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which tracks read/write dependencies between transactions rather than locking the rows a transaction reads."}

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

{"answer": "204", "explanation": "HTTP 204 No Content indicates a successful request that returns no response body, which is commonly used for DELETE operations."}

{"answer": "yes", "explanation": "DELETE is idempotent because the first request removes the resource and any subsequent identical requests leave the state unchanged (resource remains deleted)."}

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

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests is the standard status code used to signal that a client has exceeded the allowed rate limit of requests."}

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

{"answer": "yes", "explanation": "RFC 5789 does not require PATCH to be idempotent, whereas PUT is required by RFC 7231 to be idempotent, making the statement true."}

```json ⏎ {"answer": "no", "explanation": "Using == for hash comparison is vulnerable to timing attacks and can suffer from PHP type-juggling; you should use the timing-safe hash_equals() function instead."} ⏎ ```

{"answer": "yes", "explanation": "A CSRF token is generated server-side, associated with the user's session, embedded in forms, and validated server-side on unsafe (state-changing) requests to ensure the request originates from the legitimate site."}

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

```json ⏎ {"answer": "no", "explanation": "OAuth 2.0 is strictly an authorization framework, not an authentication protocol—the access token grants access to resources but does not verify or reveal the user's identity, which requires OpenID Connect."} ⏎ ```

{"answer": "no", "explanation": "XSS is prevented by escaping/encoding output at the point of rendering, not by validating input before storage, since stored data can still be exploited when rendered in an unsafe browser context."}

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

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

{"answer": "no", "explanation": "A salt does not need to be secret—it is typically stored alongside the hash in the database, and its security comes from being random and unique, not from secrecy."}

```json ⏎ {"answer": "no", "explanation": "PHPUnit only recognizes and runs test methods in classes that extend PHPUnit\Framework\TestCase, which provides the assertion methods and the test lifecycle (setUp/tearDown)."} ⏎ ```

{"answer": "false", "explanation": "In PHPUnit, setUp() runs before EACH test method, not once before all tests; setUpBeforeClass() is the method that runs only once before all tests in the class."}

```json ⏎ {"answer": "no", "explanation": "A data provider supplies multiple sets of arguments, allowing a single test method to run repeatedly with different data, not just one set."} ⏎ ```

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

{"answer": "false", "explanation": "The statement is reversed: a stub only returns canned data, while a mock verifies which methods were called."}

{"answer": "yes", "explanation": "In PHPUnit 10+, data providers are passed using the #[DataProvider] attribute, while the older @dataProvider annotation syntax has been deprecated."}

{"answer": "no", "explanation": "PHPUnit allows test dependencies via the @depends annotation, enabling one test to depend on the result (including return values) of another."}

{"answer": "--order-by=random", "explanation": "The `--order-by=random` option tells PHPUnit to shuffle the execution order of tests."}

{"answer": "3-3", "explanation": "intdiv(7,2) returns 3 and intdiv(-7,2) returns -3 because truncation is toward zero, and the concatenation yields \"3-3\"."}

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

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

{"answer": "other", "explanation": "The string 'a' loosely equals neither 0 nor any non-zero number, so it does not match case 0 and falls through to the default block which echoes 'other'."}

```json ⏎ {"answer": "2c", "explanation": "In strtr() with an associative array, it scans left to right and replaces the longest matching key first, so 'ab' matches before 'a' and becomes '2', leaving 'c' unchanged."} ⏎ ```

```json ⏎ {"answer": "[hello]", "explanation": "substr from -10 on a 5-character string starts at the beginning and returns the entire string 'hello', wrapped in brackets."} ⏎ ```

{"answer": "k,n,m", "explanation": "The union operator + keeps the left array's values for overlapping keys ('k'=>1 from $a, $b's 'k'=>9 ignored), preserving order k, n, then m, so array_keys gives k,n,m."}

{"answer": "yxz", "explanation": "usort sorts by the third element (index 2) in ascending order, giving [2,'y',1],[1,'x',2],[3,'z',2], then array_column extracts the second elements y,x,z and implode joins them into \"yxz\"."}

{"answer": "4", "explanation": "The spread operator unpacks the associative array by key name, so `$a` receives 5 and `$b` receives 1, making 5 - 1 = 4."}

```json ⏎ {"answer": "3", "explanation": "The `$p->g(...)` syntax creates a closure bound to the object P that invokes g() with no additional arguments; the closure holds an internal reference to the object, so even after `$p = null`, calling `$f()` still returns the private value 3."} ⏎ ```

```json ⏎ {"answer": "B", "explanation": "The method uses `static::class` which relies on late static binding, so it returns the runtime class name B rather than the declared class A."} ⏎ ```

{"answer": "Compile error (parse/fatal error)", "explanation": "The code uses property hooks (getters/setters) syntax, which is not implemented or supported in PHP 8.5, so the file fails to parse rather than producing the doubled value of 10."}

{"answer": "BA", "explanation": "The conflict between TA::f and TB::f is resolved by using TB::f for f(), while TA::f is aliased to g(), so f() returns 'B' and g() returns 'A'."}

{"answer": "", "explanation": "The code produces a fatal error because PHP does not allow type declarations on static properties, so the echo statement never executes and nothing is output."}

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

```json ⏎ {"answer": "second", "explanation": "The inner try throws RuntimeException, but the finally block's throw of LogicException overrides it, and this propagates to the outer catch which echoes 'second'."} ⏎ ```

```json ⏎ {"answer": "App\\Foo|Baz", "explanation": "`Baz::class` resolves through the `use App\\Foo as Baz` alias within namespace N to `App\\Foo`, while `\\Baz::class` is the fully-qualified global reference producing the literal string `Baz`, and the `::class` operator does not require the class to exist."} ⏎ ```

{"answer": "yesyes", "explanation": "Both checks resolve to Ns\\Foo, which exists, so the first check qualifies 'Foo' against the current namespace and the second uses the fully-qualified name, both returning true."}

{"answer": "1,2,99", "explanation": "After the reference foreach loop, $v still points to the last element $a[2], so $v = 99 overwrites that last element to 99, resulting in the array [1, 2, 99]."}

```json ⏎ {"answer": "3", "explanation": "The static local variable $n belongs to the function A::inc() itself and is shared across all instances and any class that inherits the method without overriding it, so the three calls increment it to 1, 2, and 3 respectively."} ⏎ ```

{"answer": "11", "explanation": "Calling send(10) resumes the generator after `yield 1`, making `$x` equal to 10, so the function returns `10 + 1 = 11`, which getReturn() retrieves."}

```json ⏎ {"answer": "1,2,ok", "explanation": "yield from propagates inner's yielded values (1 and 2) and assigns inner's return value 'ok' to $r, which is then yielded, giving the array [1,2,'ok']."} ⏎ ```

{"answer": "noyes", "explanation": "The hash was created with cost 4, so password_needs_rehash returns false (no) when cost 4 matches but true (yes) when a higher cost 5 is requested."}

{"answer": "strict-in", "explanation": "E_ALL is a bitmask that includes the bit value 2048 (E_STRICT), so (E_ALL & 2048) equals 2048, which is not identical to 0, making the ternary evaluate to 'strict-in'."}

```json ⏎ {"answer": "mapped", "explanation": "The server var HTTP_X_TOKEN is converted to the X-Token header, which HeaderBag stores and retrieves case-insensitively, so get('X-Token') returns 'abc'."} ⏎ ```

{"answer": "BCA", "explanation": "Symfony's EventDispatcher calls listeners in descending priority order, so B (priority 10) runs first, then C (priority 5), then A (default priority 0)."}

```json ⏎ {"answer": "same", "explanation": "Doctrine's identity map (first-level cache) stores entities by primary key within a single EntityManager, so two find() calls with the same ID return the identical object instance."} ⏎ ```

{"answer": "0", "explanation": "Persisting then removing the same un-flushed entity cancels both operations in Doctrine's Unit of Work, so no INSERT executes and the table stays empty."}

{"answer": "1", "explanation": "COUNT(x) counts only non-NULL values of x, and since one of the two rows contains NULL, only the value 1 is counted."}

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

{"answer": "M1M2", "explanation": "The M1 middleware echoes first, then calls next which triggers M2 to echo, before the stack is exhausted and throws a LogicException."}

```json ⏎ {"answer": "11", "explanation": "Both handlers ($d1 adding 1 and $d2 adding 10) are registered for the Ping message and carry distinct aliases ('h1' and 'h2'), so the HandlersLocator keeps both and HandleMessageMiddleware invokes each, making $n equal 1 + 10 = 11."} ⏎ ```

{"answer": "1", "explanation": "The first INSERT adds value 1, the unique index prevents duplicates so the second INSERT's conflict triggers DO NOTHING, leaving exactly one row."}

{"answer": "2", "explanation": "The UNIQUE constraint is DEFERRED, so it is not checked until COMMIT; since no COMMIT occurs, both INSERTs succeed and the SELECT sees both rows."}

{"answer": "6", "explanation": "The `--filter test_sum` uses a regex that matches both `test_sum` and `test_sum_abs` (since test_sum is a substring), giving 3+3=6 tests."}

{"answer": "2, 1", "explanation": "The data provider supplies 2 data sets ([1] and [-1]), so 2 tests run; the assertion passes for 1 but fails for -1, so 1 fails."}

{"answer": "POST", "explanation": "The `-d` option in curl sends data using the HTTP POST method with an `application/x-www-form-urlencoded` content type."}

{"answer": "GET", "explanation": "The `-d` flag normally sends a POST request, but adding `-G` overrides this and appends the data to the URL as query parameters, causing a GET request."}

{"answer": "invalid_client", "explanation": "When client authentication fails due to a non-existent client_id, RFC 6749 Section 5.2 specifies the endpoint must return an \"invalid_client\" error indicating the client was not found or authentication failed."}

```json ⏎ { ⏎   "answer": "fragment (hash)", ⏎   "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access_token is returned in the URI fragment (after the # symbol) of the redirect_uri so that it is not sent to the server and cannot be leaked via referrer headers or server logs." ⏎ } ⏎ ```

```json ⏎ {"answer": "6", "explanation": "Twig considers `false` an empty value, so `false|default(2)` evaluates to `2`, and `2 * 3` produces `6`."} ⏎ ```

{"answer": "2", "explanation": "Twig's `~` binds tighter than `+`, so `'a' ~ 1 + 2` evaluates as `('a' ~ 1) + 2` = `'a1' + 2`; PHP casts the non-numeric string `'a1'` to `0`, giving `0 + 2 = 2` with no exception thrown."}

{"answer": "1", "explanation": "The empty string violates the NotBlank constraint, producing exactly one validation violation that count() returns."}

```json ⏎ {"answer": "LogicException", "explanation": "Calling isValid() before submit() on a Symfony form throws a \\LogicException (\"Form instances should not be validated without being submitted\"), which is caught and its class name is printed."} ⏎ ```

{"answer": "same", "explanation": "Public services in a compiled Symfony DI container are instantiated once and cached in the container's instances array, so both `$c->get('a')` calls return the same object instance."}

```json ⏎ {"answer": "hi Bob!", "explanation": "The DependencyInjector resolves nested parameter placeholders during compile, so '%greeting%!' becomes 'hi %name%!' then 'hi Bob!'."} ⏎ ```

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

{"answer": "text-danger", "explanation": "Both classes have equal specificity, so the one appearing later in the generated CSS wins; danger is defined after primary in Bootstrap's $theme-colors map ordering."}

```json ⏎ {"answer": "2", "explanation": "OrderService is in the Domain layer, which may only depend on Domain, so depending on both the Application layer (PlaceOrder) and the Infrastructure layer (Db) produces two violations."} ⏎ ```

{"answer": "3", "explanation": "The class is in the Domain layer, which may only depend on Domain classes, so all three external dependencies (Application\\PlaceOrder, Infrastructure\\Db, Infrastructure\\Logger) violate the rule."}

```json ⏎ {"answer": "10,15", "explanation": "The object $a retains its immutable amount of 10 while $c holds the sum 15."} ⏎ ```

{"answer": "1", "explanation": "The 'add' sets items to ['a' => true], and 'remove' throws a DomainException because count is 1, so the item is never unset, leaving count at 1."}

```json ⏎ {"answer": "hi", "explanation": "Since PHP 8.1 you can call methods directly on the result of a `new` expression, so `new C()->hi()` returns the string 'hi' which echo prints."} ⏎ ```

```json ⏎ {"answer": "yesno", "explanation": "`newLazyGhost` creates an uninitialized lazy object that remains uninitialized (output 'yes') until a property is accessed, at which point the callback runs and the object becomes initialized (output 'no')."} ⏎ ```

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

```json ⏎ {"answer": "noyes", "explanation": "On Symfony 8.1, AnnotationClassLoader was removed (deprecated in 6.1, removed in 7.0) so it returns 'no', while AttributeClassLoader still exists so it returns 'yes'."} ⏎ ```