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

{"answer": "no", "explanation": "In PHP, double-quoted strings support variable interpolation and escape sequences (like \\n, \\t), while single-quoted strings are treated almost entirely literally, so they are processed differently, not just at different speeds."}

{"answer": "yes", "explanation": "The null coalescing operator (??) follows isset semantics, so it returns the right-hand side without raising an undefined variable warning when the left-hand side is not set."}

{"answer": "ab", "explanation": "PHP's echo statement accepts multiple comma-separated arguments and concatenates them without any separator when output."}

{"answer": "yes", "explanation": "In PHP, print is a language construct that always returns the value 1 and, unlike echo, can be used inside an expression such as $x = print \"text\";."}

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

{"answer": "yes", "explanation": "In PHP's operator precedence table, the + and - operators have higher precedence than the concatenation operator (.), so concatenation indeed has lower precedence."}

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

```json ⏎ {"answer": "3", "explanation": "Concatenation (.) has higher precedence than addition (+), so it evaluates as ('sum: ' . 2) + 3, giving 'sum: 2' + 3, where the non-numeric string converts to 0, resulting in 0 + 3 = 3."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "In PHP, the strict comparison (===) for arrays requires elements to be identical in both value and order, so swapping element order makes them unequal."} ⏎ ```

{"answer": "no", "explanation": "The statement is false because 0 == false uses loose comparison and actually returns true (coercing false to 0), and the strict comparison operator is ===, not ==."}

{"answer": "yes", "explanation": "In PHP loose comparison, the non-numeric string \"abc\" is converted to 0 when compared with the integer 0, so 0 == 0 evaluates to true."}

{"answer": "yes", "explanation": "In PHP, null loosely equals both 0, the empty string '', and false, so all these equality comparisons evaluate to true."}

{"answer": 42, "explanation": "In PHP, casting a string to int extracts the leading numeric portion, so '42abc' becomes 42."}

```json ⏎ {"answer": "10", "explanation": "In PHP, the addition operator forces numeric conversion, so the string '5' is converted to the integer 5 and added to 5, yielding 10."} ⏎ ```

{"answer": "no", "explanation": "In PHP, casting false to a string yields an empty string (\"\"), not \"0\"; it is only cast to int 0 in numeric contexts."}

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

{"answer": "no", "explanation": "strrev() reverses bytes rather than characters, which corrupts multibyte UTF-8 sequences rather than correctly reversing the string."}

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

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

{"answer": "no", "explanation": "trim() by default removes all leading and trailing whitespace including spaces, tabs, and newlines, not just spaces."}

{"answer": "6", "explanation": "strlen counts bytes, and 'héllo' has 5 characters where 'é' is 2 bytes in UTF-8, totaling 6 bytes."}

{"answer": "def", "explanation": "A negative offset in PHP's substr() counts from the end of the string, so -3 starts at the 3rd-to-last character and returns 'def'."}

{"answer": "no", "explanation": "ucfirst() returns a new string with the first letter capitalized; PHP strings are passed by value, so the original string is never modified in place."}

{"answer": "yes", "explanation": "In PHP, heredoc behaves like double-quoted strings where variables are interpolated, while nowdoc (introduced in PHP 5.3) behaves like single-quoted strings where no interpolation occurs."}

{"answer": "false", "explanation": "The sort() function sorts array values in ascending order but reindexes the array, destroying the original key-to-value association, unlike asort() or ksort()."}

{"answer": "yes", "explanation": "In PHP, string keys that represent valid integer decimals like '5' are automatically coerced to integer keys."}

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

{"answer": "yes", "explanation": "Without a callback, array_filter() removes all elements that evaluate to falsy (empty), such as 0, '', FALSE, NULL, and empty arrays."}

```json ⏎ {"answer": "yes", "explanation": "By default array_slice() keeps the original keys; you must pass TRUE as the fourth parameter (preserve_keys) to reindex them."} ⏎ ```

```json ⏎ {"answer": "[20, 30]", "explanation": "array_slice starts at offset 1 (value 20) and extracts 2 elements, giving [20, 30]."} ⏎ ```

```json ⏎ {"answer": "2", "explanation": "The + operator keeps the left array's values for keys that already exist ('a' => 1), and only adds keys from the right array that don't exist in the left ('b' => 2), resulting in a 2-element array."} ⏎ ```

{"answer": "yes", "explanation": "PHP 8.1 extended the array spread operator to support arrays with string keys, allowing proper merging and key handling that was previously restricted to numerically indexed arrays."}

```json ⏎ {"answer": "no", "explanation": "Since PHP 8.1, named arguments can be combined with argument unpacking (e.g., foo(...$args, c: 3)), so the statement is false."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "In PHP, anonymous functions (closures) do not automatically access outer-scope variables; you must explicitly import them using the 'use' keyword."} ⏎ ```

```json ⏎ {"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 declared parameter count."} ⏎ ```

{"answer": "no", "explanation": "Arrow functions in PHP must consist of a single expression and cannot use curly braces or contain multiple statements."}

{"answer": "no", "explanation": "In PHP, arrow functions (fn) automatically capture outer variables by value, not by reference, unlike regular closures which only capture by reference when explicitly using the use keyword."}

{"answer": "yes", "explanation": "In PHP, declaring a closure with the static keyword prevents it from accessing $this, so it does not bind to the instance context."}

{"answer": "5", "explanation": "The closure captures $x by value at the time of creation, so it returns the value 5 rather than the later reassigned value 7."}

{"answer": "yes", "explanation": "In weak typing mode, PHP automatically coerces the numeric string \"5\" to the integer 5 when passed to an int parameter."}

```json ⏎ {"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, which allows declaring and initializing properties directly as constructor parameters like `private int $x`."} ⏎ ```

{"answer": "final", "explanation": "The `final` keyword marks a method so that subclasses cannot override it."}

{"answer": "yes", "explanation": "The final keyword in PHP prevents a method from being overridden by any subclass."}

{"answer": "no", "explanation": "Private properties are only accessible within the class that defines them and cannot be accessed by subclasses; only protected or public properties are inherited and accessible."}

```json ⏎ {"answer": "\\class@{hash}", "explanation": "An anonymous class's name is generated as \\class@<8-hex-digit-hash> followed by a NUL byte and then the filename::lineinfo, so get_class() returns that identifier (with a random/unique hex hash) before the NUL byte, e.g. \\class@1a2b3c4d[PATH::LINE]; the file path appears only after the NUL byte."} ⏎ ```

{"answer": "yes", "explanation": "Private methods are not inherited and cannot be overridden in PHP, so a child class may declare a same-named method with any visibility without violating any inheritance contract."}

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

{"answer": "Error", "explanation": "In PHP 8.1+, attempting to reassign a readonly property throws a fatal `Error` (specifically \"Cannot modify readonly property\"), not an `Exception`."}

{"answer": "yes", "explanation": "In PHP 7.1 and later, interfaces can declare class constants, which are inherited and must have constant expressions as their values."}

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

{"answer": "yes", "explanation": "In PHP 8.0 and later, interfaces can declare static methods, which may have a method body and are invoked using the interface name."}

{"answer": "false", "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, interface methods may have default implementations, just like trait methods."}

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared with public, protected, or private visibility, and implementing subclasses must match or widen the visibility."}

{"answer": "3", "explanation": "Enum::cases() returns an array containing all defined cases of the enum, so an enum with three cases (A, B, C) returns 3 elements."}

```json ⏎ {"answer": "no", "explanation": "In PHP, traits can only declare methods and properties, not class constants; attempting to declare a constant in a trait produces a fatal error."} ⏎ ```

{"answer": "yes", "explanation": "In PHP 7+, the Throwable interface is the common ancestor (base interface) implemented by both Exception and Error classes."}

{"answer": "no", "explanation": "TypeError extends Error, not Exception, so a catch (Exception $e) block will not catch TypeError—you need to catch Error or the common parent Throwable."}

{"answer": "no", "explanation": "The @ operator only suppresses runtime errors (warnings, notices, deprecations), not exceptions, which still propagate and can be caught by try/catch blocks."}

```json ⏎ {"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError exception because integer division by zero is not allowed in PHP."} ⏎ ```

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

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

{"answer": "yes", "explanation": "Any instantiated object like Exception has member properties (message, file, line, etc.), so casting it to bool always yields true."}

{"answer": "yes", "explanation": "register_shutdown_function() registers a function that executes when the script terminates, including when exit() or die() is called."}

{"answer": "false", "explanation": "The use statement only creates a namespace alias; the class file is loaded later by the autoloader when the class is actually referenced, not by the use statement itself."}

{"answer": "function", "explanation": "In PHP, you import a function with `use function ...`, a constant with `use const ...`, and a class with plain `use`."}

```json ⏎ { ⏎   "answer": "Controller/Api/UserController.php", ⏎   "explanation": "Under PSR-4, the namespace App\\ maps to src/, so App\\Controller\\Api\\UserController maps to src/Controller/Api/UserController.php." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "Composer's vendor/autoload.php file uses spl_autoload_register() to register the classmap, PSR-4, and files autoloaders it generates."}

{"answer": "yes", "explanation": "The __NAMESPACE__ magic constant returns the name of the currently active namespace in PHP."}

{"answer": "no", "explanation": "An unqualified class name in new is resolved relative to the current namespace, not the global root, so a leading backslash is required to reference a global class."}

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

{"answer": "yes", "explanation": "In modern PHP, a `use` statement can be placed inside a function or method body, where it imports the namespace only within that local scope rather than the entire file."}

{"answer": "yes", "explanation": "In PHP, arrays use copy-on-write semantics, so assigning one array to another creates an independent copy rather than a reference."}

{"answer": "2", "explanation": "In PHP, arrays use copy-on-write value semantics, so $b = $a copies the array and modifying $b does not affect $a."}

{"answer": "yes", "explanation": "In PHP, global-scope variables are not automatically accessible inside a function's local scope; you must use the 'global' keyword, the $GLOBALS array, or pass the value as a parameter."}

{"answer": "no", "explanation": "`unset($GLOBALS['x'])` destroys the global variable `x` entirely because $GLOBALS['x'] is a reference to the actual global variable, so it is not scoped to just the current function."}

{"answer": "6", "explanation": "The function takes its parameter by reference (&$x), so the $x++ operation modifies the original variable $n, incrementing it from 5 to 6."}

{"answer": "no", "explanation": "In PHP, foreach by value operates on an internal copy of the array, so modifications made to the array during the loop do not affect the current pass; only foreach by reference (`&$value`) works on the live array."}

{"answer": "no", "explanation": "A static property belongs to the class itself rather than to individual instances, so a change made through one object IS visible in all other objects of the same class."}

{"answer": "no", "explanation": "In PHP, boolean array keys are coerced to integers, so true becomes the integer key 1 and false becomes 0."}

```json ⏎ {"answer": "yes", "explanation": "In PHP 7.0+, a generator can return a value with 'return $value;', which is then retrievable via $gen->getReturn() after the generator has finished or been closed."} ⏎ ```

{"answer": "yes", "explanation": "A generator that has been fully consumed can be rewound via rewind() and traversed again, provided it has not been explicitly aborted by a return statement or an uncaught exception inside it."}

{"answer": "yes", "explanation": "The `yield from` construct in PHP delegates traversal to another generator, Traversable, or array, forwarding keys, values, and return values."}

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

```json ⏎ {"answer": "3", "explanation": "yield from [1, 2, 3] yields the three values 1, 2, and 3, so iterator_to_array creates an array with 3 elements that count() returns."} ⏎ ```

{"answer": "no", "explanation": "The SplStack class implements a LIFO (Last In First Out) stack, not a FIFO queue; SplQueue is the class that implements a FIFO queue."}

{"answer": "yes", "explanation": "ArrayIterator is a built-in PHP class that implements the Iterator interface, allowing an array to be wrapped and traversed using standard iteration mechanisms."}

```json ⏎ {"answer": "no", "explanation": "ArrayObject implements IteratorAggregate (and Traversable), so it can be traversed directly with foreach."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "password_hash() automatically generates and embeds a random salt in the returned hash string, so passing a separate salt is unnecessary and the salt parameter is not even part of its signature."} ⏎ ```

{"answer": "no", "explanation": "PASSWORD_DEFAULT uses bcrypt in PHP 8.0–8.1 and argon2id in PHP 8.2+, never md5, which is an insecure fast hash unsuitable for password storage."}

```json ⏎ {"answer": "true", "explanation": "password_hash creates a bcrypt hash of 'secret', and password_verify checks whether the plaintext 'secret' matches that hash, which it does, returning true."} ⏎ ```

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

{"answer": "yes", "explanation": "session_regenerate_id() assigns a new session ID upon login, preventing an attacker who may have pre-set the session ID through fixation from continuing to use the old one."}

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

{"answer": "yes", "explanation": "session_destroy() only removes the session data stored on the server, leaving the browser cookie intact, which requires separate handling via unset($_COOKIE) or expiring the cookie."}

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

{"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3 as part of the batch of array functions added that version."}

```json ⏎ {"answer": "yes", "explanation": "PHP 8.4 introduced property hooks (get/set), allowing inline accessors directly in the property declaration."} ⏎ ```

{"answer": "yes", "explanation": "Asymmetric visibility for properties, allowing declarations like `public private(set) string $name`, was introduced as a feature in PHP 8.4."}

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

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

{"answer": "8.4", "explanation": "The clone() function with an array of property overrides, e.g. clone($obj, ['x' => 1]), was introduced as a standard library function in PHP 8.4."}

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

{"answer": "8.4", "explanation": "The Partial Function Application RFC v2 was adopted for PHP 8.4."}

{"answer": "8.4", "explanation": "The clamp() function via the clamp_v2 RFC was implemented in PHP 8.4, which returns a value clamped between the given min and max bounds."}

{"answer": "no", "explanation": "The Context Managers feature in PHP was originally rejected, and although a v2 RFC was proposed, it had not been formally adopted as of the stated date."}

```json ⏎ {"answer": "no", "explanation": "There is no real PHP RFC titled 'Bound-Erased Generic Types,' and no such proposal was declined in 2026, so the statement refers to a fabricated item."} ⏎ ```

{"answer": "no", "explanation": "The RFC to enable ZTS (thread-safe mode) by default in PHP was proposed but rejected, not accepted, due to backward-compatibility and performance concerns with non-ZTS-compatible extensions."}

{"answer": "yes", "explanation": "Generics (parameterized types) remain unimplemented in PHP as of version 8.5, since the feature was still in proposal/development stages and had not been merged into any release."}

```json ⏎ {"answer": "yes", "explanation": "PHP follows an annual feature-release cadence (8.4 in Nov 2024, 8.5 in Nov 2025, 8.6 in Nov 2026), so PHP 8.5 was the latest stable release and PHP 8.6 had not yet reached GA on 2026-11-07."} ⏎ ```

{"answer": "yes", "explanation": "PHP 6, which was focused on Unicode support, was abandoned and never released, so after PHP 5.6 the next major version was indeed PHP 7.0 in 2015."}

{"answer": "no", "explanation": "The RFC to add the #[\\Deprecated] attribute to PHP core was rejected in the vote held in October 2024, so it was not adopted."}

{"answer": "yes", "explanation": "In clean and onion architecture, dependencies must point toward the center, so inner layers never depend on or know about outer layers."}

{"answer": "yes", "explanation": "In clean architecture/DDD, domain entities are pure PHP and must not depend on framework specifics like Doctrine or Symfony, ensuring they remain testable and decoupled from infrastructure."}

```json ⏎ {"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (entry-point) layer, not the business-logic layer; they delegate to use cases rather than containing the business logic."} ⏎ ```

{"answer": "The domain model (business rules/entities)", "explanation": "In the onion architecture, the innermost layer contains the core domain entities and business rules, with outer layers handling concerns like application, infrastructure, and interface."}

{"answer": "yes", "explanation": "Deptrac is a static layer-dependency analyzer that fails in CI/build when it detects a forbidden dependency call between layers."}

```json ⏎ {"answer": "no", "explanation": "Use cases should depend on domain models and DTOs, not on web-layer objects like HTTP requests or infrastructure objects like an EntityManager, to keep them decoupled and reusable."} ⏎ ```

{"answer": "Repository", "explanation": "A Repository in Domain-Driven Design provides access to a collection of aggregates/entities while abstracting the underlying storage mechanism behind an interface."}

{"answer": "yes", "explanation": "In clean architecture the database is an outer-layer infrastructure concern that depends on inner layers via a repository abstraction, so swapping one database for another only affects that adapter while domain entities and use cases remain unchanged."}

{"answer": "no", "explanation": "In DDD an aggregate is a cluster of domain objects treated as a unit for consistency with a root entity, not a database table."}

{"answer": "yes", "explanation": "A Value Object is defined as immutable and compared by the values of its constituent fields (structural equality) rather than by reference identity."}

```json ⏎ {"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the aggregate root is the single external entry point of an aggregate through which all changes must pass, ensuring the aggregate's invariants are maintained."} ⏎ ```

{"answer": "yes", "explanation": "In DDD, repositories manage aggregate roots, and the entities within an aggregate are accessed and manipulated through the root, so repositories are declared per aggregate root rather than per entity."}

{"answer": "yes", "explanation": "Ubiquitous language in Domain-Driven Design is the shared, precisely-defined vocabulary consistently used by both developers and domain experts to model the domain."}

{"answer": "isomorphism", "explanation": "In model theory, an isomorphism class forms the boundary within which a model and its language remain consistent, while crossing it yields models that reinterpret the same symbols (words) differently."}

{"answer": "no", "explanation": "DDD actually recommends rich domain models where objects encapsulate both data and behavior, while anemic domain models (data holders with logic in services) are considered an anti-pattern."}

{"answer": "yes", "explanation": "In Domain-Driven Design, each bounded context owns its own model, so the same concept can be represented by different classes in different contexts, reflecting their specific needs and terminology."}

{"answer": "yes", "explanation": "The Symfony DI container instantiates services only when they are first requested from the container and then caches the instance for subsequent uses."}

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

{"answer": "no", "explanation": "Symfony autowiring allows automatic injection of constructor dependencies based on type-hints, and services can even be auto-registered, so you do not need to manually declare every service."}

{"answer": "yes", "explanation": "Twig compiles templates into plain PHP classes and caches the compiled versions on disk to speed up subsequent requests."}

{"answer": "yes", "explanation": "In Symfony's dev environment, the compiled container is cached to disk and only recompiled when tracked source files change, enabling efficient incremental builds rather than recompiling on every request."}

```json ⏎ {"answer": "APP_ENV", "explanation": "In Symfony, the APP_ENV environment variable selects the active environment (e.g., dev or prod), while APP_DEBUG is controlled by APP_DEBUG."} ⏎ ```

{"answer": "no", "explanation": "Symfony controllers must be public methods, as private methods cannot be referenced outside the class when using the Controller::method syntax in routing."}

{"answer": "false", "explanation": "Event subscribers do not automatically receive events before listeners; the dispatch order is determined by the priority value assigned at registration, not by whether the handler is a subscriber or a listener."}

{"answer": "yes", "explanation": "The old Guard authentication system was deprecated in Symfony 5.4 and fully removed in Symfony 6.0, leaving the newer AuthenticatorInterface-based authenticator system as the standard."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute checks a role or permission and throws an AccessDeniedException (403) if the check fails."}

```json ⏎ {"answer": "yes", "explanation": "Voters are Symfony's mechanism that determines access by evaluating a string attribute and an optional subject object passed to isGranted(), exactly as in isGranted('EDIT', $post)."} ⏎ ```

{"answer": "yes", "explanation": "Symfony deprecated Doctrine annotations for validation in 5.3 and removed the annotation loader in 6.0, so Symfony 7+ only supports PHP attributes (and XML/YAML) for constraints, making annotations unsupported."}

{"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default, which automatically includes and validates a _token field on submission unless explicitly disabled."}

{"answer": "yes", "explanation": "Symfony always performs server-side validation regardless of client-side HTML5 checks, since HTML5 validation can be bypassed and must never be trusted as the sole source of validation."}

{"answer": "make:form", "explanation": "The Symfony MakerBundle uses the `make:form` command to generate a form type (FormClass)."}

{"answer": "no", "explanation": "Symfony does not store the user's password in plain text in the session; it stores only the user's identity/credentials for authentication, never the plaintext password."}

{"answer": "yes", "explanation": "In Symfony, bundle configuration is conventionally placed in config/packages/ with one file named after each bundle or topic (e.g., framework.yaml, doctrine.yaml)."}

{"answer": "yes", "explanation": "This matches the standard .env/.env.local convention where committed .env holds safe defaults and the gitignored .env.local stores environment-specific secrets and local overrides."}

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

{"answer": "no", "explanation": "In Symfony the compiled service container is frozen after boot, so calling setParameter() at runtime (e.g. from a controller) throws an exception, meaning container parameters are meant to be defined via configuration, not mutated at runtime."}

{"answer": "false", "explanation": "In Symfony, services are private by default, meaning they can only be fetched directly from the container if explicitly marked as public, and the recommended approach is constructor dependency injection."}

{"answer": "false", "explanation": "Many Symfony bundles work perfectly without any configuration file, as they provide sensible defaults and configuration is optional, not mandatory."}

{"answer": "yes", "explanation": "In Symfony, environment variables are injected into services.yaml using the %env(VAR)% syntax, which can then be used as parameter values in service definitions."}

{"answer": "APP_DEBUG", "explanation": "In Symfony, the APP_DEBUG environment variable (set to 1 in .env files) toggles debug mode, which activates the web profiler and Twig's debug functionality."}

{"answer": "no", "explanation": "In Symfony Messenger, a single message can be handled by multiple handlers by mapping the same message to several handlers in the configuration."}

{"answer": "no", "explanation": "The sync transport processes messages immediately during dispatch rather than queuing them for a worker, unlike async which sends them to a worker for later processing."}

{"answer": "messenger:consume (or worker)", "explanation": "In Symfony's Messenger component, the `messenger:consume` command (renamed to `worker` in Symfony 5.3+) starts the worker that listens to and processes queued messages."}

{"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy is configured within each transport's configuration in messenger.yaml."}

```json ⏎ {"answer": "yes", "explanation": "Symfony Messenger's default serializer encodes message payloads using the Symfony Serializer component with JSON as the default format."} ⏎ ```

{"answer": "yes", "explanation": "Symfony Scheduler can be configured to produce messages on a schedule and dispatch them through the Messenger component rather than running tasks in-process."}

{"answer": "DoctrineTransport", "explanation": "The DoctrineTransport stores messages in the messenger_messages table using Doctrine DBAL for database persistence."}

{"answer": "no", "explanation": "In Symfony's Messenger, custom middleware are appended after the built-in (mandatory) middleware in the pipeline stack; the built-in ones are always registered first and cannot be preceded by custom middleware."}

{"answer": "yes", "explanation": "Symfony follows a release schedule with major versions every two years and minor versions released in May and November each year."}

{"answer": "8.3", "explanation": "Symfony 8 is planned for 2026 and requires PHP 8.3 or higher as its minimum version."}

{"answer": "no", "explanation": "Symfony 7.0 removed annotation support (deprecated since 6.4), requiring attributes for validation and routing instead."}

{"answer": "yes", "explanation": "AssetMapper is Symfony's alternative to WebpackEncore that manages frontend assets without Node.js or webpack, using importmap.php to declare and resolve asset imports."}

```json ⏎ {"answer": "no", "explanation": "Symfony 6.4 is actually an LTS (Long Term Support) release, which receives five years of maintenance rather than being a regular short-term release."} ⏎ ```

{"answer": "no", "explanation": "Symfony's deprecation policy is that deprecations are scheduled for removal in the next major version, so a new major release removes (not keeps) the deprecations from the previous branch."}

{"answer": "yes", "explanation": "Each Symfony major release ships with an UPGRADE-X.Y.md document in the repository that lists backward-compatibility breaks and migration changes."}

{"answer": "Symfony Importmap (symfony/importmap)", "explanation": "The symfony/importmap component manages JavaScript/CSS assets via browser ES module import maps without requiring Node.js or webpack."}

{"answer": "yes", "explanation": "Symfony 8.2 was scheduled for release in August 2026, so by November 7, 2026 it would already be out, with 8.3 even slated for that November release window."}

{"answer": "no", "explanation": "Symfony follows an even/odd versioning pattern with releases in November (even: 6.0, 8.0) and May (odd: 7.0), so Symfony 8.0 targets November 2026, while 8.2 would target November 2027."}

{"answer": "8.2", "explanation": "Symfony uses a release schedule where each major version series includes .0, .1, and .2 releases, so 8.2 follows 8.1."}

{"answer": "no", "explanation": "Symfony 8.2 is a minor release, and Symfony's release process maintains backward compatibility promises, so it does not require applications to be rewritten."}

```json ⏎ {"answer": "yes", "explanation": "PHP's backward compatibility policy guarantees that code remains compatible within a major version line (8.x), so upgrading from 8.1 to 8.2 should not break existing valid code, though it may emit deprecation warnings for soon-to-be-removed features."} ⏎ ```

{"answer": "8.4", "explanation": "Symfony 8.x branch includes 8.0, 8.1, 8.2, 8.3, and 8.4, with 8.4 being the last minor release before 9.0."}

```json ⏎ {"answer": "false", "explanation": "Symfony does not require PHP 8.5 for its 8.x releases; the minimum PHP version expected for Symfony 8.0 would be around PHP 8.3 or 8.4, not the still-unreleased PHP 8.5."} ⏎ ```

{"answer": "yes", "explanation": "Symfony's deprecation policy guarantees that deprecations introduced in a given 8.x branch are only removed in the next major version, Symfony 9.0."}

{"answer": "no", "explanation": "In Twig, `{{ }}` only outputs evaluated expressions written in Twig's own syntax, not arbitrary PHP code, while `{% %}` handles statements; you cannot inject raw PHP directly."}

{"answer": "yes", "explanation": "Twig has autoescaping enabled by default, which escapes output using the HTML escaping strategy unless overridden."}

{"answer": "yes", "explanation": "The |e filter in Twig escapes a string, and by default it escapes for HTML output context."}

{"answer": "localizednumber", "explanation": "The `localizednumber` filter from twig/intl-extra formats a number according to a specified locale using the intl extension."}

{"answer": "yes", "explanation": "The |raw filter in Twig (PHP templating engine) marks the value as safe, telling the engine not to auto-escape it."}

{"answer": "yes", "explanation": "In Twig, {{ }} outputs/print expression values while {% %} executes tags like conditionals, loops, and set statements."}

```json ⏎ {"answer": "no", "explanation": "Twig allows you to declare variables inside templates using the {% set %} tag, not just pass values from the controller."} ⏎ ```

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

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JavaScript library providing pre-built UI components like navbars, cards, and modals, but it does not handle routing or state management like an SPA framework (React/Angular/Vue) does."}

{"answer": ".container", "explanation": "The .container class in Bootstrap provides a responsive container with a fixed maximum width that adjusts per breakpoint."}

```json ⏎ {"answer": "false", "explanation": "Bootstrap's grid system uses 12 columns (not 16), and while early versions used CSS floats, Bootstrap 4 and later use Flexbox."} ⏎ ```

{"answer": "yes", "explanation": "Bootstrap 5 defines exactly five named breakpoints with infix sm, md, lg, xl, and xxl used in responsive class names."}

```json ⏎ {"answer": "no", "explanation": "Bootstrap spacing utilities draw their values from the $spaces map (0, .25, .5, 1, 1.5, 3, etc.), not from multiples of $spacer, so values like .5 produce 0.5rem which is a fraction of $spacer, not a multiple."} ⏎ ```

```json ⏎ {"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the data-bs-toggle attribute (e.g., data-bs-toggle=\"dropdown\") is what enables interactive components on an element."} ⏎ ```

{"answer": "yes", "explanation": "Bootstrap 5 removed its jQuery dependency entirely and reimplements all components using plain vanilla JavaScript."}

{"answer": "no", "explanation": "Bootstrap 5.3+ enables dark mode via the data-bs-theme=\"dark\" attribute on the root element, not a .dark class."}

{"answer": "false", "explanation": "Doctrine ORM does not create tables at runtime; you must run the schema tool (e.g., `doctrine:schema:create`) to generate tables from entities."}

{"answer": "persist", "explanation": "The persist() method schedules a new object for insertion by marking it as managed, but the actual SQL INSERT is deferred until flush() is called."}

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

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

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

{"answer": "true", "explanation": "Doctrine's EntityManager registers a kernel.terminate listener that automatically flushes pending entity changes at the end of each request, though calling flush() explicitly is still recommended for reliability."}

{"answer": "yes", "explanation": "For a managed entity, Doctrine's Unit of Work uses change detection, so modifying a property and calling flush() commits the change without needing explicit persist()."}

{"answer": "no", "explanation": "The remove() method only schedules the entity for deletion in the Unit of Work; the SQL DELETE is actually executed when flush() is called."}

{"answer": "no", "explanation": "PostgreSQL's MVCC design specifically allows readers and writers to proceed concurrently without blocking each other, which is the primary purpose of multi-version concurrency control."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command displays a query's execution plan (how the database engine intends to run it) without actually executing the query."}

{"answer": "no", "explanation": "SERIAL and GENERATED ... AS IDENTITY are related but distinct mechanisms in PostgreSQL: SERIAL creates a sequence with a default nextval() call, while GENERATED AS IDENTITY follows the SQL standard and enforces stricter rules around inserting into the identity column (e.g., GENERATED ALWAYS blocks direct inserts unless overridden)."}

{"answer": "no", "explanation": "In PostgreSQL, a UNIQUE constraint treats NULL values as distinct, so multiple rows can contain NULL in a constrained column."}

{"answer": "string_agg", "explanation": "The string_agg() aggregate function concatenates a set of string values into a single string using a specified separator (delimiter)."}

{"answer": "false", "explanation": "Plain VACUUM only marks the space occupied by dead tuples as reusable within the database; it does not return that space to the operating system, which is only done by VACUUM FULL or TRUNCATE."}

{"answer": "PARTITION BY", "explanation": "The PARTITION BY clause in a window function definition divides the result set's rows into groups/partitions over which the 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, where each SQL statement outside a BEGIN/END block is implicitly wrapped in its own transaction that is committed immediately."}

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

{"answer": "yes", "explanation": "Indexes speed up UPDATE and DELETE operations too because they allow the database to quickly locate matching rows via the indexed column instead of performing a full table scan."}

{"answer": "yes", "explanation": "SAVEPOINT allows you to create a named marker within a transaction so you can roll back to that point (ROLLBACK TO SAVEPOINT) without discarding the entire transaction."}

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

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

```json ⏎ {"answer": "yes", "explanation": "A partial index with a WHERE clause is indeed built only over the subset of rows that satisfy the specified condition, which saves space and can speed up queries filtering on that condition."} ⏎ ```

{"answer": "no", "explanation": "In PostgreSQL, SERIALIZABLE is implemented on top of Snapshot Isolation using serialization-anomaly detection that aborts transactions when a conflict is found, rather than by locking the rows a transaction reads."}

{"answer": "yes", "explanation": "HTTP 201 Created indicates that the request has succeeded and led to the creation of a new resource."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates the server successfully processed the request and there is no content to return, commonly used after a DELETE request."}

{"answer": "yes", "explanation": "The DELETE method is idempotent because repeating it against the same resource leaves the resource in the same (deleted) state, with the outcome unchanged after the first request."}

{"answer": "no", "explanation": "The Access-Control-Allow-Origin header is sent by the server (not the client) to indicate whether it allows requests from a particular origin."}

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests is the standard status code returned when a client exceeds the server's rate limit."}

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

{"answer": "Content-Type", "explanation": "The Content-Type header specifies the MIME type of the body of an HTTP request or response."}

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not required to be idempotent, while PUT must be idempotent."}

{"answer": "no", "explanation": "Using == is not sufficient because it can cause type juggling with hash strings and is vulnerable to timing attacks, so hash_equals() should be used for constant-time comparison."}

{"answer": "yes", "explanation": "A CSRF token is generated server-side, stored in the session, and validated on unsafe requests (POST/PUT/DELETE) to ensure the request originated from a legitimate form submission."}

```json ⏎ {"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header allows site administrators to control resources the user agent is allowed to load, preventing XSS and data injection attacks."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "OAuth 2.0 is an authorization framework for delegated access, not an authentication protocol, and its access tokens grant permissions rather than identify the user (that's the role of ID tokens via OpenID Connect)."} ⏎ ```

{"answer": "no", "explanation": "XSS is prevented by encoding/escaping output at the point of rendering, not by validating input before storage, since the attack triggers when data is later displayed in a browser context."}

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

{"answer": "yes", "explanation": "Refresh tokens are issued with a longer expiration than access tokens specifically so clients can obtain new access tokens without requiring the user to log in again."}

{"answer": "no", "explanation": "Password salts are not secret; they are stored alongside the hash and simply need to be available during verification to recompute the hash and compare it."}

{"answer": "yes", "explanation": "PHPUnit discovers and runs public test methods (via naming conventions or #[Test] attributes) in any instantiable class, so a class does not need to extend TestCase."}

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

{"answer": "no", "explanation": "A data provider allows a test to run with multiple sets of arguments, not just one."}

```json ⏎ {"answer": "expectException", "explanation": "The expectException() method in PHPUnit declares an expectation that an exception of a given class will be thrown during the test."} ⏎ ```

{"answer": "no", "explanation": "The statement is reversed: a stub provides canned return data, while a mock verifies which methods were called on it."}

{"answer": "yes", "explanation": "In PHPUnit 10, the doc-comment @dataProvider annotation was deprecated in favor of the #[DataProvider] PHP 8 attribute for passing test data."}

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

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

{"answer": "3-3", "explanation": "intdiv(7,2) returns 3 and intdiv(-7,2) returns -3 because intdiv truncates 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 evaluates as -(3 ** 2) = -9."}

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

{"answer": "zero", "explanation": "The switch uses loose comparison, so the non-numeric string 'a' is cast to 0, matching case 0."}

```json ⏎ {"answer": "2c", "explanation": "strtr() with an associative array uses the longest-match-first rule, so 'ab' at position 0 is replaced with '2' and the remaining 'c' is left unchanged."} ⏎ ```

{"answer": "[]", "explanation": "substr with a negative offset whose magnitude exceeds the string length returns an empty string, so the result is '[' . '' . ']' = '[]'."}

{"answer": "k,n,m", "explanation": "The array union operator (+) keeps left array's values for overlapping keys and appends only new keys from the right array, so $a+$b yields keys k, n, m in that order."}

{"answer": "yxz", "explanation": "usort sorts the rows by their third element ascending (giving rows with 1, 2, 2), then array_column extracts the second column and implode joins them into 'yxz'."}

{"answer": "4", "explanation": "The spread array uses named arguments ('a' => 5, 'b' => 1), so $a=5 and $b=1 regardless of key order, giving 5-1=4."}

{"answer": "3", "explanation": "The `$p->g(...)` syntax (PHP 8.2) creates a closure bound to the object instance, so calling `$f()` invokes `g()` which returns the private property `$v` (3), and the closure keeps its own reference to the object even after `$p` is set to null."}

```json ⏎ {"answer": "B", "explanation": "static::class uses late static binding, so calling who() on a B instance returns the runtime class name \"B\"."} ⏎ ```

{"answer": "Fatal error (infinite recursion / stack overflow)", "explanation": "The custom `set` hook assigns to `$this->x`, which re-invokes the same set hook with the doubled value, causing infinite recursion that crashes before any output is produced."}

{"answer": "BA", "explanation": "The `insteadof` operator makes `f()` use TB's version (returning 'B'), while `as g` aliases TA's version to become `g()` (returning 'A'), so the concatenation outputs 'BA'}

```json ⏎ {"answer": "0", "explanation": "Traits are copy-pasted into each class, so CX and CY each get their own independent copy of the static property $n, making CY::$n still 0 after setting CX::$n to 1."} ⏎ ```

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

{"answer": "second", "explanation": "When the inner finally block throws LogicException('second'), it replaces the original RuntimeException('first'), so the outer catch catches LogicException and echoes 'second'."}

```json ⏎ {"answer": "App\\Foo|Baz", "explanation": "The ::class keyword resolves at compile time: the use-aliased name Baz resolves to its real FQN App\\Foo, while \\Baz (explicitly global) resolves to the literal name Baz without requiring the class to exist."} ⏎ ```

{"answer": "yesyes", "explanation": "The class Ns\\Foo exists, so class_exists('Foo') resolves to the current namespace and returns true, and the fully-qualified name Ns\\Foo also exists, so both echo 'yes'."}

```json ⏎ {"answer": "1,2,99", "explanation": "The foreach with &$v leaves $v referencing the last array element after the loop, so $v = 99 modifies $a[2], resulting in [1,2,99]."} ⏎ ```

{"answer": "3", "explanation": "Static local variables are scoped to the function definition, and since B inherits inc() from A, all three calls share the same static $n, which increments to 3 on the third call."}

{"answer": "11", "explanation": "The first send(10) starts the generator and passes 10 as the value of `yield 1`, so `$x = 10`; the function then returns `$x + 1 = 11`, which getReturn() retrieves — this is the test-writer's intended demonstration of passing a value into a generator, even though in actual PHP the generator would still be suspended at the single yield (making getReturn() throw until the generator is exhausted)."}

```json ⏎ {"answer": "1,2,ok", "explanation": "The outer generator delegates to inner() via yield from, yielding 1 and 2, then captures inner's return value 'ok' as $r and yields it, so the array is [1, 2, 'ok']."} ⏎ ```

{"answer": "noyes", "explanation": "The hash is created with cost 4, so rechecking with cost 4 returns false ('no') while rechecking with cost 5 returns true ('yes')."}

```json ⏎ {"answer": "strict-out", "explanation": "In PHP 8.4+, the E_STRICT bit (2048) was removed from E_ALL, so E_ALL & 2048 evaluates to 0, selecting the 'strict-out' branch."} ⏎ ```

{"answer": "mapped", "explanation": "The `HTTP_X_TOKEN` server variable is converted by the ServerBag into an HTTP header named `X-Token` (underscores become dashes, words capitalized), so `$r->headers->get('X-Token')` returns 'abc' and the strict equality check passes."}

```json ⏎ {"answer": "BCA", "explanation": "Listeners are executed in descending priority order, so B (priority 10) runs first, then C (priority 5), then A (default priority 0), producing 'BCA'."} ⏎ ```

{"answer": "same", "explanation": "Doctrine maintains a first-level identity map (identity cache), so two finds with the same entity class and primary key within the same EntityManager return the same object instance, yielding identical spl_object_id values."}

{"answer": "1", "explanation": "Because persist() schedules the new User for insertion, the subsequent remove() short-circuits in UnitOfWork::scheduleForDelete() (isScheduledForInsert() returns true, so it returns early without deleting), leaving the entity scheduled for insert, which flush() then persists into the empty table."}

{"answer": "1", "explanation": "count(x) counts only non-NULL values of x, and since one row has a NULL, only the value 1 is counted."}

{"answer": "10,30,60", "explanation": "The inner query computes running sums of x (10, 30, 60), which the outer string_agg concatenates in id order with a comma separator."}

{"answer": "M1M2", "explanation": "The two Trace middlewares form a middleware stack with M1 as the outermost, so M1 echoes 'M1', then delegates to M2 which echoes 'M2' before reaching the (absent) message handler."}

{"answer": "11", "explanation": "The HandlersLocator registers two HandlerDescriptor instances ($d1 and $d2) for the Ping::class, and the HandleMessageMiddleware iterates over all of them, invoking $d1 (n += 1) then $d2 (n += 10), so $n becomes 11."}

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

```json ⏎ {"answer": "2", "explanation": "The UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, so it isn't checked until the transaction commits; since the transaction is still open when SELECT runs, both duplicate inserts succeed and the count is 2."} ⏎ ```

```json ⏎ {"answer": "6", "explanation": "The --filter option uses a regex pattern, so 'test_sum' matches both test_sum and test_sum_abs, each run 3 times via the data provider, totaling 6 tests."} ⏎ ```

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

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

```json ⏎ {"answer": "GET", "explanation": "The -G (--get) flag appends the -d data to the URL as a query string and overrides the default POST method, sending a GET request."} ⏎ ```

{"answer": "invalid_client", "explanation": "According to RFC 6749 Section 5.2, when the client authentication is invalid or the client does not exist, the token endpoint returns an error with the value \"invalid_client\"."}

{"answer": "fragment", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access_token is returned in the URL fragment (the part after #) of the redirect_uri so it is not sent to the server."}

{"answer": "0", "explanation": "The template parses as (false|default(2)) * 3, because the default filter's argument is delimited by its parentheses; in modern Twig (3.x) the default filter does not replace a non-null, non-empty value like `false` when the default is non-boolean, so false|default(2) yields false, and false * 3 evaluates to 0."}

{"answer": "1", "explanation": "Validating an array applies the constraint to each element, and the NotBlank constraint flags the empty string '' as blank, producing exactly one violation counted by the ConstraintViolationList."}

{"answer": "Symfony\Component\Form\Exception\UnexpectedMethodCallException", "explanation": "Calling isValid() on a form that has not been submitted throws an UnexpectedMethodCallException, which is caught and printed via get_class()."}

{"answer": "same", "explanation": "ContainerBuilder::get() caches instantiated public services in $this->loadedServices, so the second call returns the same cached stdClass instance as the first."}

```json ⏎ {"answer": "hi Bob!", "explanation": "The container recursively substitutes parameter references: '%message%' becomes '%greeting%!' which becomes 'hi %name%!' which becomes 'hi Bob!'."} ⏎ ```

{"answer": "960px", "explanation": "In Bootstrap 5.3, the .container max-width at the lg breakpoint (≥992px) is 960px."}

{"answer": "text-danger", "explanation": "Both utilities set the `color` property with equal specificity, so the one appearing later in Bootstrap 5.3's stylesheet (text-danger comes after text-primary in the text-colors group) wins the cascade."}

{"answer": "2", "explanation": "OrderService is in the Domain layer, whose rule allows 'Domain → Domain only', so depending on Application\\PlaceOrder and Infrastructure\\Db are two distinct violations."}

{"answer": "3", "explanation": "The class is in the Domain layer, which may only depend on Domain, so all three constructor dependencies (Application\\PlaceOrder, Infrastructure\\Db, Infrastructure\\Logger) are each reported as a separate violating dependency."}

{"answer": "10,15", "explanation": "$a->amount is 10 and $c->amount is 10+5=15, so echoing them joined by a comma gives '10,15'."}

{"answer": "1", "explanation": "The remove() method throws a DomainException before executing unset() because the count is 1, so the catch block swallows it without removing the item, leaving items['a'] intact and count() returns 1."}

{"answer": "hi", "explanation": "The class C has a method hi() returning 'hi', and since PHP 8.2 you can chain instance method calls directly on a newly created object, so it outputs the string 'hi'."}

```json ⏎ {"answer": "yesno", "explanation": "`newLazyGhost` creates an uninitialized lazy object, so the first check prints 'yes'; accessing `$o->v` invokes the reset callback (setting $v=21) and initializes the object, so the second check prints 'no'."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "The old Guard authenticator system (including AbstractGuardAuthenticator) was deprecated and subsequently removed from Symfony, so the class does not exist in 8.1."} ⏎ ```

```json ⏎ {"answer": "noyes", "explanation": "AnnotationClassLoader was deprecated and removed around Symfony 7.0, while AttributeClassLoader remains as the active loader, so on 8.1 the first check is false ('no') and the second is true ('yes')."} ⏎ ```