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

{"answer": "false", "explanation": "Double-quoted strings support variable interpolation and escape sequences like \\n and \\$, while single-quoted strings are treated almost literally, so they are not processed identically."}

{"answer": "yes", "explanation": "The null coalescing operator (??) follows isset() semantics, so it does not emit warnings for undefined variables."}

{"answer": "ab", "explanation": "In PHP, echo can output multiple comma-separated arguments, which are concatenated and printed in sequence."}

{"answer": "yes", "explanation": "print is a PHP language construct that always returns the value 1, and unlike echo it can be used within an expression because it yields a return value (e.g., $x = (print \"hello\");)."}

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

{"answer": "no", "explanation": "In PHP 8.0, the concatenation operator's precedence was raised to be higher than addition and subtraction, so it now binds more tightly than + and -."}

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

{"answer": "3", "explanation": "The concatenation operator . has higher precedence than +, so it evaluates as ('sum: ' . 2) + 3, giving 'sum: 2' + 3; the non-numeric string converts to 0, and 0 + 3 equals 3."}

{"answer": "no", "explanation": "In PHP, the === operator considers arrays equal only if they have the same key/value pairs in the same order and of the same types, so element order does matter."}

{"answer": "no", "explanation": "The statement is false because `0 == false` actually returns true (0 is loosely equal to false), and `==` is a loose comparison, not a strict one (which is `===`)."}

{"answer": "no", "explanation": "In PHP 8, \"abc\" is a non-numeric string, so it's compared against the string \"0\", making \"abc\" == 0 false."}

{"answer": "yes", "explanation": "In PHP loose comparison, null, 0, empty string, and false all compare equal to each other via ==."}

{"answer": 42, "explanation": "In PHP, casting a string starting with digits to int converts the leading numeric portion and stops at the first non-numeric character, so '42abc' becomes 42."}

{"answer": "10", "explanation": "In PHP, the + operator performs arithmetic addition, converting the string '5' to the number 5, so '5' + 5 equals the integer 10."}

{"answer": "no", "explanation": "When cast to string, false becomes an empty string \"\", not \"0\"; only true becomes \"1\" and numeric 0 becomes \"0\"."}

{"answer": "yes", "explanation": "Because floating-point arithmetic gives 0.1 + 0.2 = 0.30000000000000004, which is strictly (===) not equal to 0.3, so the comparison returns false."}

{"answer": "no", "explanation": "strrev() reverses bytes one-by-one, so multi-byte UTF-8 characters get corrupted and must use mb_strrev() instead."}

{"answer": "yes", "explanation": "str_contains() returns a boolean, and since 'world' is found within 'Hello world', it returns the boolean true."}

```json ⏎ {"answer": "no", "explanation": "str_pad() can pad on the left, right, or both sides using the STR_PAD_LEFT, STR_PAD_RIGHT, and STR_PAD_BOTH constants, not the right side only."} ⏎ ```

{"answer": "no", "explanation": "By default, PHP's trim() strips all whitespace characters including \\0, \\t (tab), \\n (newline), \\r (carriage return), and spaces, not just spaces."}

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

{"answer": "def", "explanation": "A negative offset counts from the end of the string, so -3 starts at 'd' and returns 'def'."}

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

{"answer": "yes", "explanation": "Heredoc uses the <<<EOT delimiter and interpolates variables like double-quoted strings, while nowdoc uses <<<'EOT' and behaves like single-quoted strings that do not interpolate variables."}

```json ⏎ {"answer": "no", "explanation": "sort() reindexes the array with new numeric keys and does not preserve the key-to-value association; asort() is used to preserve keys."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, string array keys that look like valid integers are automatically cast to integer keys, so '5' becomes the integer key 5."}

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

{"answer": "yes", "explanation": "Without a callback, array_filter() keeps only the elements that evaluate to true, effectively removing all falsy values (false, null, \"\", 0, \"0\", empty arrays)."}

{"answer": "no", "explanation": "By default array_slice() reindexes/ignores the original keys, so you must pass true as the $preserve_keys argument to keep them."}

```json ⏎ {"answer": "[20, 30]", "explanation": "array_slice starts at offset 1 (value 20) and returns 2 elements, reindexing them numerically from 0."} ⏎ ```

{"answer": "2", "explanation": "The union operator (+) keeps the left array's values and only adds right array values whose keys don't already exist, so ['a'=>1]+['a'=>9,'b'=>2] = ['a'=>1,'b'=>2], which has 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 extended the array spread operator to support associative arrays with string keys, which was previously only allowed with integer keys."}

{"answer": "false", "explanation": "PHP 8.1 allows combining named arguments with unpacking of associative arrays whose string keys match parameter names, so the statement is false."}

{"answer": "no", "explanation": "In PHP, anonymous functions only inherit outer-scope variables when explicitly declared with the use keyword, so without it they cannot access those variables."}

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

```json ⏎ {"answer": "no", "explanation": "Arrow functions (fn()) in PHP support only a concise syntax consisting of a single expression without curly braces; multiple statements require a regular function."} ⏎ ```

{"answer": "no", "explanation": "PHP arrow functions automatically capture outer variables by value, not by reference, so the statement is false."}

{"answer": "yes", "explanation": "In PHP, a closure declared with the `static` keyword is not bound to an object and therefore does not have access to `$this` or capture it from the enclosing scope."}

```json ⏎ {"answer": "5", "explanation": "The closure captures $x by value at the moment of creation, so it holds the copy 5, not the later reassigned value 7."} ⏎ ```

{"answer": "yes", "explanation": "In weak typing mode, PHP coerces the string \"5\" to an integer automatically due to type juggling."}

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, allowing properties like `private int $x` to be declared directly in the constructor signature."}

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

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

{"answer": "no", "explanation": "Private properties are only accessible within the class that declares them, not in subclasses, which is why they are not inherited or accessible in derived classes."}

{"answer": "", "explanation": "An anonymous class created with `new class {}` has no user-defined name; PHP generates an internal name that begins with a NUL marker byte (before the embedded file path/line info), so the portion of the name before the first NUL byte is empty."}

{"answer": "yes", "explanation": "Private methods are not inherited and are not part of the inheritance contract, so a child class is free to declare a method with the same name at any visibility level without conflict."}

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

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP (8.1+) throws an Error of type 'Cannot modify a readonly property', not an Exception."}

{"answer": "yes", "explanation": "In PHP, interfaces can declare constants, and any class implementing the interface inherits those constants."}

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

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces are allowed to declare static methods, which can be called using the interface name or implemented by classes."}

{"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, interfaces can provide default method implementations with a method body, similar to how trait methods work."}

{"answer": "yes", "explanation": "In PHP, abstract methods can declare any visibility modifier including public, protected, or private, so a protected abstract method is allowed."}

```json ⏎ {"answer": "3", "explanation": "Foo::cases() returns an array containing all enum cases, so it returns 3 elements for the three cases A, B, and C."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, traits can declare class constants in addition to properties and methods."}

{"answer": "yes", "explanation": "In PHP, Throwable is the base interface implemented by both Exception and Error classes, making it their common ancestor."}

```json ⏎ {"answer": "false", "explanation": "TypeError extends Error (which implements Throwable), not Exception, so a catch (Exception $e) block will not catch it—you would need to catch Error or Throwable."} ⏎ ```

{"answer": "false", "explanation": "The @ operator only suppresses runtime errors, not exceptions, which are still thrown regardless of the suppression operator."}

{"answer": "DivisionByZeroError", "explanation": "intdiv() throws a DivisionByZeroError (which extends ArithmeticException) when the divisor is zero."}

{"answer": "no", "explanation": "The finally block always executes regardless of whether an exception was thrown or caught, running whenever the try block exits."}

{"answer": "no", "explanation": "An exception thrown inside a finally block actually overrides and replaces any return value or previously thrown exception from the try/catch block."}

{"answer": "yes", "explanation": "Casting any non-empty object like an Exception instance to boolean always yields true because it has properties (message, code, trace, etc.)."}

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

```json ⏎ {"answer": "no", "explanation": "The `use` statement only imports a class name into the current namespace for shorthand reference; it does not load the file, which is handled by the autoloader when the class is actually used."} ⏎ ```

{"answer": "const", "explanation": "In ES6 modules you import a function using a const binding (e.g., `import { fn }` and use it as a value), whereas classes are imported with the class keyword in declaration syntax, so functions are referenced via const."}

```json ⏎ {"answer": "Controller/Api/UserController.php", "explanation": "In PSR-4 autoloading, the namespace prefix 'App\\' is mapped to the 'src/' directory, so the remaining namespace segments 'Controller\\Api\\User' (with the class name) are converted from backslashes to forward slashes and appended to a '.php' suffix, yielding Controller/Api/UserController.php."} ⏎ ```

{"answer": "yes", "explanation": "Composer's vendor/autoload.php loads the autoloader which registers PSR-4, classmap, and files handlers via spl_autoload_register()."}

{"answer": "yes", "explanation": "The __NAMESPACE__ magic constant in PHP does contain the name of the current namespace."}

{"answer": "no", "explanation": "An unqualified class name in a new statement is resolved relative to the current namespace, not from the global root; you must prefix it with a backslash to access the global scope."}

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

{"answer": "yes", "explanation": "In PHP, a use statement can be written inside a function or method body, and the namespace import then applies only to that function's scope."}

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

{"answer": "2", "explanation": "Arrays use copy-on-write semantics, so $b = $a creates an independent copy and $b[] = 3 modifies only $b, leaving $a with 2 elements."}

{"answer": "yes", "explanation": "In PHP, all variables are function-scoped by default, so global variables cannot be accessed inside a function without the global keyword, $GLOBALS array, or by passing them as parameters."}

```json ⏎ {"answer": "no", "explanation": "unset($GLOBALS['x']) inside a function actually permanently deletes the global variable 'x' from the global scope, not just within that function's local scope."} ⏎ ```

{"answer": "6", "explanation": "Since $x is passed by reference, incrementing it inside the function modifies $n, which becomes 6."}

{"answer": "no", "explanation": "For arrays, foreach operates on a copy of the array by value, so modifications made to the array inside the loop are NOT visible during the current iteration pass."}

{"answer": "no", "explanation": "Static properties belong to the class itself rather than individual instances, so changes made through one object are visible in all others."}

{"answer": "no", "explanation": "In PHP, boolean keys in arrays are automatically converted to integers (true becomes 1), so they are not stored as bool."}

```json ⏎ {"answer": "yes", "explanation": "PHP 7+ supports returning a value from a generator, which can be retrieved via $gen->getReturn() once the generator is exhausted."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Regular PHP generators are single-use and cannot be rewound once consumed; only the RewindableGenerator interface (PHP 8.1+) allows re-traversal, and even then a normally exhausted generator's rewind() returns false."} ⏎ ```

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

{"answer": "Generator", "explanation": "A function using yield is a generator function that returns a Generator object when called, so get_class() returns the string \"Generator\"."}

{"answer": "3", "explanation": "The generator yields three values (1, 2, 3), so iterator_to_array produces an array with 3 elements that count() returns as 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (last in, first out) stack, not a FIFO queue; SplQueue implements the FIFO queue behavior."}

{"answer": "yes", "explanation": "ArrayIterator is an SPL class that wraps an array and provides iteration through the Iterator interface (and related interfaces like SeekableIterator, ArrayAccess)."}

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

{"answer": "yes", "explanation": "password_hash() automatically generates a random salt and embeds it in the resulting hash, so you don't need to provide one separately."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT uses the bcrypt algorithm (or the strongest available at the time), not MD5, which is cryptographically broken and unsuitable for password hashing."}

{"answer": "true", "explanation": "password_verify returns a boolean (true) when the plain-text password matches the hash generated by password_hash of the same value."}

{"answer": "false", "explanation": "strip_tags() only removes HTML/PHP tags and has no bearing on SQL injection, which is prevented by using parameterized queries or proper input escaping for the database."}

{"answer": "yes", "explanation": "session_regenerate_id() changes the session ID upon login, invalidating the attacker's previously fixed session ID and thus preventing session fixation attacks."}

{"answer": "php_sapi_name()", "explanation": "php_sapi_name() returns the name of the server API interface (SAPI) such as cli, fpm-fcgi, or apache2handler."}

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

{"answer": "no", "explanation": "The $_SESSION array remains empty until session_start() is called to initialize the session and load stored session data."}

{"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3 along with other array search functions like array_find_key(), array_any(), and array_all()."}

{"answer": "yes", "explanation": "Property hooks (get/set) were indeed introduced in PHP 8.4, allowing getters and setters to be declared directly within the property declaration."}

{"answer": "yes", "explanation": "Asymmetric visibility with syntax like `public private(set) string $name` was indeed introduced in PHP 8.4, allowing public read access but private write access."}

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

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

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

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

{"answer": "8.4", "explanation": "The Partial Function Application RFC v2 was adopted for PHP 8.4, introducing the fn() with the `...` spread and the arrow function shorthand for currying/function composition."}

{"answer": "8.2", "explanation": "The clamp() function defined by RFC clamp_v2 was implemented and added in PHP 8.2."}

{"answer": "false", "explanation": "The PHP Context Managers RFC (including its v2 revision proposing a `with` statement via `__enter__`/`__exit__`) was discussed and drafted but was never formally adopted or merged into the PHP language."}

{"answer": "false", "explanation": "There is no PHP RFC titled \"Bound-Erased Generic Types,\" and no such RFC was declined in 2026; the generics discussions are fabricated or misattributed."}

{"answer": "false", "explanation": "The RFC to make ZTS the default build was not accepted because PHP Internals could not reach consensus, so PHP still defaults to the non-thread-safe (NTS) build."}

{"answer": "no", "explanation": "Generics were introduced as a preview feature in PHP 8.4 and were fully enabled as a standard language feature in PHP 8.5, so they are no longer absent."}

{"answer": "yes", "explanation": "PHP 8.5 became the latest stable GA release in November 2025, and PHP 8.6 (scheduled for GA in November 2026) would not yet be released on 2026-11-07."}

{"answer": "yes", "explanation": "PHP 6 was a development branch intended to add Unicode support but was abandoned in 2010, so the version sequence went from PHP 5.6 directly to PHP 7.0."}

{"answer": "false", "explanation": "The RFC proposing the #[\\Deprecated] attribute for PHP core was proposed and discussed but was ultimately rejected (not adopted), so the attribute does not exist in the core."}

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

```json ⏎ {"answer": "yes", "explanation": "In clean/hexagonal architecture and Domain-Driven Design, domain entities must remain pure and framework-agnostic, depending only on PHP itself and possibly SPL so they can be reused and tested without Doctrine or Symfony."} ⏎ ```

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation/interface layer, not the business-logic layer; they initiate use cases but do not contain the business logic themselves."}

{"answer": "Domain entities (the domain layer)", "explanation": "In onion architecture, the innermost layer contains the domain entities and core business rules that all other layers depend on but do not depend on anything outside."}

{"answer": "yes", "explanation": "Deptrac performs static analysis of imports/usages and fails the build when a layer violates its configured dependency rules, so forbidden cross-layer calls are caught automatically."}

{"answer": "no", "explanation": "Use cases (interactors) must depend on abstractions and plain value objects, not on concrete infrastructure details like HTTP requests or EntityManager, since passing these directly violates the Dependency Inversion Principle, tightly couples core business logic to the web/persistence layers, and defeats the purpose of clean architecture layering."}

{"answer": "Repository", "explanation": "The Repository pattern provides a collection-like interface for aggregates/entities while hiding the underlying storage mechanism behind an abstracted interface."}

{"answer": "yes", "explanation": "In clean architecture the database is an outer-layer concern that depends on interfaces defined by inner layers, so swapping the database only requires changing the outer infrastructure layer while the domain and use cases remain untouched."}

```json ⏎ {"answer": "no", "explanation": "In DDD an aggregate is a domain concept representing a cluster of domain objects treated as a unit with consistency rules and boundaries, not a database table, which is a storage concern."} ⏎ ```

{"answer": "yes", "explanation": "Value objects are immutable and defined by their attribute values rather than a distinguishing identity, so equality is determined by comparing their fields."}

```json ⏎ {"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the Aggregate Root is the single entry point that all changes to the aggregate must pass through to maintain its consistency and integrity."} ⏎ ```

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "In DDD, repositories are used to manage aggregate roots, and entities within an aggregate should not have their own repositories since they are accessed through and managed by their aggregate root." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "Ubiquitous language in Domain-Driven Design is indeed the shared language developed by developers and domain experts that pervades the model and ensures common understanding."}

{"answer": "the domain (universe) of the model", "explanation": "In model theory, a model's domain is the boundary within which the language's symbols are assigned consistent interpretations, while the same symbols receive different meanings when interpreted in other models."}

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

{"answer": "yes", "explanation": "In Domain-Driven Design, a bounded context establishes the boundary within which a particular model is valid, so the same concept (e.g., 'Customer') can be modeled as different classes in different bounded contexts."}

{"answer": "yes", "explanation": "In Symfony's DI container, services are instantiated on-demand (lazily) when first requested rather than all at once at boot time."}

```json ⏎ {"answer": "debug:routes", "explanation": "The Symfony console command `debug:routes` (formerly `debug:router` in older versions) lists all registered routes in the application."} ⏎ ```

{"answer": "no", "explanation": "Symfony autowiring is designed to automatically resolve constructor dependencies based on type hints, so you do not need to manually declare every service."}

{"answer": "yes", "explanation": "Twig compiles template source code into plain PHP classes and caches the compiled output to disk between requests to avoid recompiling templates."}

{"answer": "yes", "explanation": "In Symfony's dev environment the compiled DI container cache is invalidated and regenerated only when tracked config/service files change, not on every request."}

{"answer": "APP_ENV", "explanation": "In Symfony, the APP_ENV variable determines the active runtime environment (dev, prod, test, etc.), typically configured via the .env file or the system environment."}

{"answer": "false", "explanation": "Symfony can only invoke public controller methods, so a private (or protected) method cannot be used as a controller action."}

{"answer": "no", "explanation": "Event subscribers do not automatically receive events before listeners; the dispatcher orders all listeners (including subscribed ones) by their explicit priority value, and subscribers without a specified priority may actually run after listeners."}

{"answer": "yes", "explanation": "In Symfony 6.0, the old Guard-based authentication was removed (it was deprecated in 5.8) and replaced by the new AuthenticatorInterface-based authenticator system."}

{"answer": "#[IsGranted]", "explanation": "The #[IsGranted] attribute validates that a user has a specific role or permission before the controller method executes, returning HTTP 403 (Forbidden) when the check fails."}

```json ⏎ {"answer": "yes", "explanation": "Voters are indeed Symfony's authorization mechanism that evaluates an attribute and a subject (object) passed to isGranted() to determine whether access should be granted."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "While PHP attributes are the modern recommended way to declare validation constraints in Symfony 7, Doctrine annotations are still technically supported via the doctrine/annotations package rather than being completely removed."} ⏎ ```

{"answer": "yes", "explanation": "Symfony forms are CSRF-protected by default via the csrf_protection option (which defaults to true), and the default form theme injects a _token field that gets validated on submission."}

```json ⏎ {"answer": "yes", "explanation": "Symfony performs server-side form validation on every request regardless of HTML5 client-side checks, which are only for user experience and can be bypassed."} ⏎ ```

{"answer": "make:form", "explanation": "The `make:form` command from SymfonyMakerBundle generates a new form class (FormType)."}

{"answer": "no", "explanation": "Symfony never stores passwords in the session; it only stores an authentication identifier (like the user ID), while passwords remain securely hashed in storage."}

{"answer": "yes", "explanation": "In Symfony (especially with Flex), bundle and topic configurations are conventionally placed in config/packages, with one YAML file per bundle or configuration topic."}

{"answer": "yes", "explanation": "In PHP frameworks like Symfony, the .env file with default dev values is committed to version control while .env.local holds machine-specific secrets and is gitignored."}

```json ⏎ {"answer": "debug:container", "explanation": "The Symfony `debug:container` command displays all services registered in the application's dependency injection container along with their aliases."} ⏎ ```

{"answer": "no", "explanation": "Once the Symfony service container is compiled and loaded, it becomes frozen, so calling $container->setParameter() at runtime throws a FrozenContainerException and cannot change parameters."}

{"answer": "false", "explanation": "By default in Symfony, services are private (public: false); you must set them to public explicitly if you want to fetch them directly from the container, though it's recommended to use dependency injection instead."}

{"answer": "false", "explanation": "Bundles work fine with default configuration and do not require a config file in config/packages; configuration is optional and only needed when customizing behavior."}

{"answer": "yes", "explanation": "In Symfony, environment variables are injected into services.yaml using the %env(VAR)% placeholder syntax, which is resolved at runtime."}

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable controls Symfony's debug mode, which enables the profiler and Twig template debugging."}

{"answer": "no", "explanation": "A single message can be handled by multiple handlers because Symfony Messenger supports multiple dispatch, where all registered handlers for a message type are invoked."}

{"answer": "no", "explanation": "The sync transport processes messages immediately through the bus without queuing, while the async transport queues messages to be consumed by a worker."}

```json ⏎ {"answer": "messenger:consume", "explanation": "In Symfony's Messenger component, the `messenger:consume` command starts the worker that processes queued messages from the bus."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy (including max_retries, retry_multiplier, and delay) is configured within each transport's DSN/config, making it a per-transport setting."}

{"answer": "no", "explanation": "By default, Symfony Messenger uses the DefaultSerializer which relies on PHP's native serialize() function, not JSON serialization."}

{"answer": "yes", "explanation": "The Symfony Scheduler component (Symfony 7.1+) can schedule MessageTask instances that dispatch messages through the Messenger component on the configured schedule."}

{"answer": "DoctrineTransport", "explanation": "The DoctrineTransport is the Symfony Messenger built-in transport that persists messages to database tables managed via Doctrine ORM."}

{"answer": "yes", "explanation": "In Symfony's Messenger component, you can register custom middleware and control their position in the pipeline relative to the built-in ones using the `from`/`to` matching configuration."}

{"answer": "yes", "explanation": "Symfony releases minor (feature) versions twice a year in May and November, and major versions every two years in May of even-numbered years."}

{"answer": "8.3", "explanation": "Symfony 8 requires PHP 8.3 or higher, continuing the pattern of Symfony major versions incrementing their minimum PHP version requirement."}

{"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations (they were deprecated in 6.4), requiring PHP attributes for validation and routing instead."}

{"answer": "yes", "explanation": "Symfony's AssetMapper manages frontend dependencies through importmap.php using ES import maps, eliminating the need for node, npm, or webpack build tools."}

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release released in November 2023, not a regular release."}

{"answer": "no", "explanation": "In Symfony, major releases are exactly when deprecated code from the previous branch is removed, which is a core part of the versioning policy."}

{"answer": "yes", "explanation": "Symfony provides UPGRADE guides with each major release documenting the changes and steps needed for migration."}

{"answer": "symfony/importmap", "explanation": "The Symfony component that manages assets and importmaps without requiring Node.js or Webpack is symfony/importmap."}

```json ⏎ {"answer": "false", "explanation": "Symfony 8.0 shipped in November 2025, and with Symfony's biannual release cycle, version 8.2 would not be released until later in November 2026, so it was not yet out on 2026-11-07."} ⏎ ```

{"answer": "no", "explanation": "Under Symfony's six-month release cycle, version 8.0 (not 8.2) is scheduled for November 2026, while 8.2 would arrive in November 2027."}

{"answer": "8.2", "explanation": "Symfony versions increment sequentially within a major release line, so the version following 8.1 is 8.2."}

{"answer": "no", "explanation": "Symfony 8.2 is a minor release within the 8.x series, not a major release; only the X.0 releases (like 8.0) are major releases that break backward compatibility and require code changes."}

{"answer": "yes", "explanation": "PHP maintains full backward compatibility within a version series, so upgrading between minor releases like 8.1 → 8.2 should not break existing code."}

```json ⏎ {"answer": "8.3", "explanation": "Symfony releases major versions in November of even years (9.0 in November 2026), and the minor 8.x releases (8.1 in Feb 2026, 8.2 in June 2026, 8.3 in Oct 2026) mean 8.3 is the last 8.x version before 9.0."} ⏎ ```

{"answer": "no", "explanation": "Symfony 8.0 targets PHP 8.3 as the minimum, and minor releases like 8.2 would not jump to requiring the unreleased PHP 8.5."}

{"answer": "yes", "explanation": "Symfony's deprecation policy removes deprecated code in the next major version, so deprecations introduced in 8.x are retained until 9.0 and not removed before then."}

{"answer": "false", "explanation": "Twig's {{ }} syntax only outputs evaluated expressions and does not allow arbitrary PHP code to be called directly; statements use {% %} and arbitrary PHP execution is intentionally restricted."}

{"answer": "yes", "explanation": "Twig enables auto-escaping by default (using the 'html' strategy) for outputted variables in templates."}

{"answer": "yes", "explanation": "The |e (escape) filter in Twig escapes strings to prevent XSS by encoding special HTML characters, with HTML being the default escaping strategy."}

{"answer": "number_format", "explanation": "The `number_format` filter from Twig's intl-extra component formats a number according to a given locale using the ICU number formatting patterns."}

{"answer": "yes", "explanation": "The |raw filter in Twig tells the engine to treat the value as already-safe HTML and disables auto-escaping for it."}

{"answer": "yes", "explanation": "In Twig, {{ }} is used to output/echo expression values while {% %} is used to execute tags such as if, for, and set statements."}

{"answer": "no", "explanation": "Twig allows you to declare variables inside a template using the `set` tag, so values do not come only from the controller."}

{"answer": "dump", "explanation": "The Twig dump() function displays debug information about a variable, showing the structure of arrays and objects."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "Bootstrap is a CSS/JavaScript library providing pre-built UI components like carousels and modals, but it does not offer client-side routing or data binding, so it is not an SPA framework like React or Vue." ⏎ } ⏎ ```

```json ⏎ {"answer": ".container", "explanation": "The .container class in Bootstrap provides a responsive container that sets a fixed maximum width at each breakpoint."} ⏎ ```

{"answer": "no", "explanation": "Bootstrap's grid uses 12 columns, not 16 (though older versions used floats, modern Bootstrap uses flexbox)."}

{"answer": "yes", "explanation": "In Bootstrap 5 the infix breakpoints used in class names are sm, md, lg, xl, and xxl (five total), while the xs breakpoint has no infix as classes are mobile-first."}

{"answer": "yes", "explanation": "In Bootstrap, spacing utility classes map to the $spacers map where each value is a multiple of the base $spacer variable, so .mt-3 yields $spacer and .px-2 yields $spacer*.5."}

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, interactive components like dropdowns, modals, and collapse are enabled by adding a `data-bs-toggle` attribute with the component name as its value."}

{"answer": "yes", "explanation": "Bootstrap 5 was rewritten from scratch and removed the jQuery dependency, so all its components and JavaScript plugins run in plain vanilla JavaScript."}

```json ⏎ {"answer": "no", "explanation": "In Bootstrap 5.3+, dark mode is enabled by setting the data-bs-theme=\"dark\" attribute on the <html> element, not by adding a .dark class."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; you must explicitly generate and execute schema migrations or run a schema-creation command."} ⏎ ```

{"answer": "persist()", "explanation": "The persist() method (in JPA/Doctrine) registers a new entity as managed in the persistence context, deferring the actual SQL INSERT until flush() is invoked."}

{"answer": "no", "explanation": "In Doctrine ORM 3, the EntityManager::merge() method was removed entirely, so it no longer exists or can make objects managed."}

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

{"answer": "null", "explanation": "In Doctrine, $repository->find(id) returns null when no entity with the given ID exists in the database."}

{"answer": "no", "explanation": "Doctrine does not auto-flush; you must explicitly call $entityManager->flush() to persist changes to the database, as the Unit of Work only tracks changes until then."}

{"answer": "yes", "explanation": "For a managed entity, Doctrine's Unit of Work performs change detection via snapshots during flush(), so modifying a tracked property is automatically persisted without an explicit persist() call."}

{"answer": "no", "explanation": "In Doctrine ORM, remove() only marks the entity for deletion by adding it to the removal set; the actual SQL DELETE is executed during flush(), not immediately."}

{"answer": "no", "explanation": "PostgreSQL's MVCC is specifically designed so that readers do not block writers and writers do not block readers, allowing concurrent execution without locks."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command in SQL displays the execution plan (query plan) for a SELECT, INSERT, UPDATE, or DELETE statement without actually executing it."}

{"answer": "no", "explanation": "SERIAL is older PostgreSQL-specific syntax that creates a sequence and sets a default value, while GENERATED ... AS IDENTITY is the more modern standard SQL approach that behaves differently with COPY, partitions, and ALTER TABLE."}

{"answer": "no", "explanation": "In PostgreSQL, a UNIQUE constraint permits multiple NULL values because NULLs are treated as distinct from one another."}

{"answer": "STRING_AGG", "explanation": "STRING_AGG is the PostgreSQL aggregate function that concatenates values from a group of rows using a specified separator (via the WITHIN GROUP ORDER BY clause)."}

{"answer": "no", "explanation": "Plain VACUUM only marks space occupied by dead tuples as reusable within the table but does not return it to the operating system; VACUUM FULL is required to reclaim space from the OS."}

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

```json ⏎ {"answer": "no", "explanation": "READ COMMITTED only prevents dirty reads, not non-repeatable reads, which are prevented at the REPEATABLE READ level and higher."} ⏎ ```

{"answer": "yes", "explanation": "PostgreSQL operates in autocommit mode by default, so each individual SQL statement is automatically wrapped in its own transaction and committed immediately after execution unless explicitly grouped with BEGIN/COMMIT."}

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

{"answer": "yes", "explanation": "Indexes are used to quickly locate rows, and UPDATE and DELETE statements with a WHERE clause on an indexed column use the same index to find matching rows faster."}

{"answer": "yes", "explanation": "SAVEPOINT creates a named marker within a transaction that you can ROLL BACK TO, allowing you to undo only part of the transaction while keeping the rest intact."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports timing/execution statistics, unlike plain EXPLAIN which shows the plan without running it."}

{"answer": "pgvector", "explanation": "The pgvector extension adds vector data types and indexing (like IVF and HNSW) to PostgreSQL for vector similarity search used in embedding-based retrieval."}

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

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which detects serialization anomalies and raises a serialization_failure error rather than locking every row read."}

{"answer": "yes", "explanation": "HTTP 201 Created indicates that the request has been successfully processed and a new resource has been created as a result."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates a successful request where the server processed it but returns no content in the response body, commonly used after DELETE operations."}

{"answer": "yes", "explanation": "The DELETE method is idempotent because repeating the request results in the same resource state—the resource is removed on the first call and remains absent on subsequent calls, so the outcome does not change."}

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

```json ⏎ {"answer": "yes", "explanation": "HTTP 429 Too Many Requests is specifically defined to indicate that a user has sent too many requests in a given amount of time, i.e., a rate limit has been exceeded."} ⏎ ```

{"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 header specifies the MIME type of the entity body sent in an HTTP request or response."}

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

{"answer": "no", "explanation": "Using == can be vulnerable to timing attacks and type-juggling issues (e.g., 0e-notation hashes being seen as numerically equal), so hash_equals() should be used for constant-time comparison."}

{"answer": "yes", "explanation": "A CSRF token is a secret, session-bound value generated by the server and included in forms/requests, then validated server-side on state-changing (POST, PUT, DELETE) requests to prevent cross-site request forgery."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to configure and enable Content Security Policy rules in the browser."}

{"answer": "false", "explanation": "OAuth 2.0 is an authorization framework, not authentication; the access token grants access to resources but does not identify the user—that is the role of OpenID Connect."}

{"answer": "no", "explanation": "XSS should be prevented by encoding output at the point of rendering, not by sanitizing input before database storage, since the same data may be used in different contexts (HTML, JavaScript, CSS, URLs) where encoding must be context-appropriate."}

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

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

{"answer": "false", "explanation": "A password salt does not need to be secret; it is stored alongside the hash in plaintext, and password verification simply retrieves the salt and re-applies it to the input password to compare hashes."}

{"answer": "yes", "explanation": "PHPUnit uses reflection to discover and execute any public methods matching the test naming convention or #[Test] attribute, so a class does not need to extend TestCase for its methods to be run."}

{"answer": "no", "explanation": "setUp() runs before every individual test method, not once before all tests; setUpBeforeClass() is what runs once before all tests in the class."}

{"answer": "no", "explanation": "A data provider is specifically designed to let a single test method run multiple times, each time with a different set of arguments from the data it returns."}

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

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

```json ⏎ {"answer": "yes", "explanation": "In PHPUnit 10, the old docblock-based @dataProvider annotation was deprecated in favor of the #[DataProvider] PHP attribute."} ⏎ ```

{"answer": "false", "explanation": "PHPUnit allows test dependencies through the @depends annotation or #[Depends] attribute, so one test can depend on another."}

{"answer": "--order-by=random", "explanation": "The --order-by=random option tells PHPUnit to execute tests in a random order instead of sequential order."}

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

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

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

{"answer": "zero", "explanation": "The switch uses loose comparison, so the string 'a' is compared to integer 0, where 'a' converts to 0, making 'a' == 0 true and matching case 0."}

```json ⏎ {"answer": "2c", "explanation": "strtr() with an array replaces longest-matching keys first, so 'ab' matches before 'a' and is replaced with '2', leaving 'c'."} ⏎ ```

{"answer": "[hello]", "explanation": "substr with a negative offset counts from the end of the string, and an offset of -10 is more negative than the string length (5), so PHP clamps it to the beginning and returns the entire string 'hello'."}

{"answer": "k,n,m", "explanation": "The union operator keeps the left operand's keys' values, so $a + $b = ['k'=>1, 'n'=>2, 'm'=>3], and array_keys joined gives 'k,n,m'."}

{"answer": "yxz", "explanation": "usort sorts rows by their third column ascending (2,1,2), placing the row ending in 1 first, and with stable sorting PHP 8+ preserves the original order of the equal rows, so the second-column values become y, x, z."}

```json ⏎ {"answer": "4", "explanation": "The spread operator unpacks the associative array using its keys as parameter names, so $a=5 and $b=1, giving 5-1=4."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "In PHP 8.1+, `$p->g(...)` with the trailing spread operator creates a closure bound to the object instance that calls `g()` when invoked, so even after `$p` is nulled the closure still holds a reference to the object and returns 3."} ⏎ ```

{"answer": "B", "explanation": "Late static binding via static::class resolves to the runtime class B since the method is invoked on a B instance."}

{"answer": "fatal error (infinite recursion)", "explanation": "The set hook assigns to $this->x, which re-triggers the set hook, causing infinite recursion until PHP hits the maximum nesting depth/stack limit and throws a fatal error."}

{"answer": "BA", "explanation": "The `insteadof` makes TB::f the actual f() method returning 'B', while the `as` alias g() exposes TA::f returning 'A', so concatenation gives 'BA'."}

{"answer": "0", "explanation": "Traits copy their members into each using class, so CX::$n and CY::$n are independent static properties, leaving CY::$n at 0."}

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

{"answer": "second", "explanation": "The inner finally block throws LogicException('second'), which overrides the RuntimeException and propagates to the outer catch that echoes the message 'second'."}

```json ⏎ {"answer": "App\Foo|Baz", "explanation": "`Baz::class` resolves through the `use` alias to `App\\Foo`, while the leading backslash in `\\Baz::class` refers to the global-namespace class `Baz` (the `::class` syntax returns the name without requiring the class to exist)."} ⏎ ```

{"answer": "yesyes", "explanation": "The class `Ns\\Foo` exists, and `class_exists('Foo')` resolves `Foo` to the current namespace `Ns\\Foo`, while `class_exists('Ns\\Foo')` explicitly matches it, so both checks return 'yes'."}

```json ⏎ {"answer": "1,2,99", "explanation": "The foreach loop binds $v by reference to the last element, so after the loop $v still points to $a[2], meaning $v = 99 modifies the last array element."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "The static $n is defined in A::inc(), and since B inherits that method without redefining it, both $a and $b share the same static $n, so the calls produce 1, 2, 3, with the last echo outputting 3."} ⏎ ```

```json ⏎ {"answer": "11", "explanation": "Calling send(10) starts the generator, assigns 10 to $x (the value yielded becomes the send value), then the generator returns $x + 1 = 11, which is also what getReturn() retrieves."} ⏎ ```

```json ⏎ {"answer": "1,2,ok", "explanation": "The yield from exposes inner's yields (1, 2), then captures inner's return value 'ok' into $r, which outer then yields, so iterator_to_array collects [1, 2, 'ok']."} ⏎ ```

```json ⏎ {"answer": "noyes", "explanation": "The hash is created with cost 4, so password_needs_rehash returns false (no) for cost 4 and true (yes) for cost 5 since the costs differ."} ⏎ ```

{"answer": "strict-in", "explanation": "2048 corresponds to E_STRICT, and since E_ALL contains all bits including 2048, the bitwise AND yields 2048 (non-zero), so the strict-in branch is taken."}

```json ⏎ {"answer": "mapped", "explanation": "Request::create parses the server bag entry HTTP_X_TOKEN into a request header named 'x-token' (lowercased), and HeaderBag::get normalizes its argument to lowercase, so it matches 'abc' and outputs 'mapped'."} ⏎ ```

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

{"answer": "same", "explanation": "The EntityManager's identity map returns the same managed instance for the same primary key on repeated find() calls after the flush assigned the ID."}

{"answer": 0, "explanation": "persist() schedules an insert for the new entity, but remove() before flush() cancels that pending insert (the entity is dropped from the insert queue or inserted and immediately deleted), so no row remains and the users table stays empty."}

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

{"answer": "\"10,30,60\"", "explanation": "The window function computes cumulative sums 10, 30, 60 ordered by id, which string_agg concatenates into a comma-separated string ordered by id."}

{"answer": "M1M2", "explanation": "The MessageBus wraps the middleware in a stack, so handle() is called for M1 first (echoing M1), then M1 calls next() to invoke M2 (echoing M2), before reaching the terminal middleware that sends the message and outputs nothing."}

{"answer": "11", "explanation": "Both `$d1` and `$d2` are registered as handlers for `Ping` with equal priority (0), so Symfony's `HandlersLocator` returns them in registration order and `HandleMessageMiddleware` invokes every matching handler once, making `$n = 1 + 10 = 11`; the extra `['alias' => 'h1']` arguments don't affect the closures since their single `$m` parameter matches the message and the alias is ignored."}

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

{"answer": "2", "explanation": "Since the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, it is only checked at transaction commit, so both INSERTs succeed before the COMMIT and count(*) returns 2."}

```json ⏎ {"answer": "6", "explanation": "The --filter test_sum is a regex that matches both test_sum (3 data sets) and test_sum_abs (3 data sets) since test_sum_abs contains the substring test_sum, giving 6 tests."} ⏎ ```

```json ⏎ {"answer": "2, 1", "explanation": "The data provider yields two test cases (x=1 and x=-1), so 2 tests run; the x=-1 case fails assertTrue since -1 > 0 is false."} ⏎ ```

{"answer": "POST", "explanation": "Using curl's `-d`/`--data` flag automatically sets the request method to POST and sends the data as a form-encoded request body."}

```json ⏎ {"answer": "GET", "explanation": "The -d flag normally uses POST, but adding -G appends the data to the URL as query string and changes the request method to GET."} ⏎ ```

```json ⏎ { ⏎   "answer": "invalid_client", ⏎   "explanation": "Per RFC 6749 §5.2, an unknown or non-existent client_id causes client authentication to fail, which the server reports as the 'invalid_client' error." ⏎ } ⏎ ```

{"answer": "fragment (hash)", "explanation": "In the OAuth 2.0 Implicit flow (response_type=token), the access_token is passed in the URL fragment/hash part rather than the query string, since the fragment is never sent to the server, reducing the risk of token leakage in logs or referrer headers."}

{"answer": "6", "explanation": "The `default` filter replaces `false` with `2` since `false` is considered empty, giving `2 * 3 = 6`."}

{"answer": "Twig\\Error\\RuntimeError", "explanation": "In Twig, `~` binds tighter than `+`, so the expression is `('a' ~ 1) + 2` = `'a1' + 2`; the `+` operator requires numeric operands and throws a Twig\\Error\\RuntimeError when given the non-numeric string 'a1'."}

{"answer": "0", "explanation": "The NotBlank constraint is applied to the root value `['']`, which is a non-empty array (not null, not `''`, not `[]`, not false, not 0), so no violation is generated and count() returns 0."}

```json ⏎ {"answer": "invalid", "explanation": "isValid() short-circuits to false because isSubmitted() returns false for a freshly created (unsubmitted) form, so the try block echoes 'invalid' without throwing."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "By default Symfony DI caches public service instances, so two `get()` calls return the same object with the same `spl_object_id()".} ⏎ ```

{"answer": "hi Bob!", "explanation": "ContainerBuilder's getParameter() recursively resolves nested parameter placeholders, so '%greeting%!' becomes 'hi %name%!' which becomes 'hi Bob!'."}

{"answer": "960px", "explanation": "At the lg breakpoint (≥992px), Bootstrap 5.3's .container has a max-width of 960px."}

{"answer": "text-danger", "explanation": "Both utilities have equal specificity, so the cascade is decided by stylesheet source order, and Bootstrap generates the danger utility after primary (danger comes later in the theme-colors palette), so text-danger wins."}

{"answer": "2", "explanation": "OrderService is in the Domain layer, which may only depend on Domain, so its two imports (Application\\PlaceOrder and Infrastructure\\Db) each constitute one violation."}

{"answer": "3", "explanation": "BillingService is in the Domain layer, whose rule allows only Domain→Domain dependencies, so its three external dependencies (PlaceOrder from Application, Db from Infrastructure, Logger from Infrastructure) each count as one violation."}

```json ⏎ {"answer": "10,15", "explanation": "$a->amount is 10 and $c->amount is the sum 10+5=15, so echo concatenates them with a comma."} ⏎ ```

{"answer": "1", "explanation": "The 'a' item is added making count 1, then remove() throws a DomainException before unsetting it (because count === 1), and the caught exception leaves the item in place, so count() returns 1."}

{"answer": "hi", "explanation": "The code instantiates class C, calls hi() which returns the string 'hi', and echoes that result directly."}

{"answer": "yeno", "explanation": "A lazy ghost object created via newLazyGhost is uninitialized until a member is accessed, so the first check outputs 'yes'; accessing $o->v triggers the initialization callback and marks the object initialized, so the second check outputs 'no'."}

{"answer": "no", "explanation": "The Symfony Guard component, including AbstractGuardAuthenticator, was deprecated in Symfony 5.x and removed entirely in Symfony 7.0, so the class does not exist in Symfony 8.1."}

{"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 6.0 (deprecated since 5.1), so it does not exist in 8.1, while AttributeClassLoader still exists."}