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

{"answer": "no", "explanation": "Double-quoted strings undergo parsing for variable interpolation and escape sequences like \\n and \\t, while single-quoted strings are treated almost literally, so they are not processed identically and speed is not the only difference."}

{"answer": "yes", "explanation": "The null coalescing operator ?? uses isset() semantics, so it never raises a warning for undefined variables and returns the left operand if it exists and is not null, otherwise the right operand."}

{"answer": "ab", "explanation": "The echo statement in PHP accepts multiple comma-separated arguments and concatenates them when outputting, so 'a' and 'b' print together as 'ab'."}

{"answer": "yes", "explanation": "In PHP, print is a language construct that always returns 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 8, the concatenation operator has lower precedence than the addition and subtraction operators, so expressions like '5 . 3 + 2' evaluate as '5 . (3 + 2)'."}

{"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."}

{"answer": "3", "explanation": "The `.` operator has higher precedence than `+`, so it evaluates as `('sum: ' . 2) + 3`, giving `'sum: 2' + 3`; since `'sum: 2'` converts to 0 numerically, the result is `0 + 3 = 3`."}

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

{"answer": "no", "explanation": "The == operator is a loose comparison, not strict, and 0 == false actually evaluates to true because 0 is coerced to false."}

{"answer": "yes", "explanation": "In PHP loose comparison, the non-numeric string \"abc\" is converted to the integer 0, so it equals 0."}

{"answer": "yes", "explanation": "Under PHP's loose comparison, null is converted to false/0/'' and therefore equals 0, the empty string, and false all at once."}

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

{"answer": "10", "explanation": "In PHP, the + operator forces both operands to be evaluated as numbers, so '5' is converted to 5 and 5 + 5 equals 10."}

```json ⏎ {"answer": "false", "explanation": "In PHP, casting the boolean false to a string produces an empty string (\"\"), not \"0\"; it is the integer 0 that becomes \"0\" when cast to string."} ⏎ ```

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

{"answer": "no", "explanation": "strrev() reverses bytes rather than Unicode characters, so it breaks multi-byte UTF-8 sequences instead of reversing characters correctly."}

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

```json ⏎ {"answer": "no", "explanation": "str_pad() can pad on the right (STR_PAD_RIGHT, default), left (STR_PAD_LEFT), or both sides (STR_PAD_BOTH), so it is not limited to right padding only."} ⏎ ```

{"answer": "no", "explanation": "By default, PHP's trim() removes all leading/trailing whitespace including spaces, tabs, newlines, carriage returns, NUL bytes, and vertical tabs, not just spaces."}

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

{"answer": "def", "explanation": "A negative offset counts from the end of the string, so substr('abcdef', -3) returns the last 3 characters."}

{"answer": "false", "explanation": "In PHP, strings are immutable and passed by value, so ucfirst() returns a new string with the first character capitalized without modifying the original string."}

```json ⏎ {"answer": "yes", "explanation": "Heredoc syntax behaves like double-quoted strings and supports variable interpolation, while nowdoc (with a quoted identifier like <<<'EOL') behaves like single-quoted strings and does not interpolate variables."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "sort() sorts array values in ascending order and resets (reindexes) the numeric keys, so it does not preserve the original key-to-value association, unlike asort()."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, string array keys that are valid integer representations are automatically converted to integer keys, so '5' is stored as 5."}

{"answer": "no", "explanation": "The in_array() function uses loose comparison by default; the strict mode (===) is only enabled when the third parameter $strict is set to true."}

{"answer": "yes", "explanation": "Without a callback, array_filter() iterates through the array and keeps only elements that are truthy, thereby removing all falsy (empty) values like false, null, 0, \"\", and \"0\"."}

{"answer": "no", "explanation": "By default, array_slice() reindexes the keys starting from 0; you must set the third $preserve_keys parameter to true to keep the original keys."}

{"answer": "[20, 30]", "explanation": "array_slice extracts 2 elements starting from offset 1, returning the elements at indices 1 and 2 which are 20 and 30."}

{"answer": "2", "explanation": "The + operator for arrays in PHP keeps the left array's elements for duplicate keys, so 'a' => 1 is kept and 'b' => 2 is added, yielding an array of 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 extended the array spread operator to support unpacking arrays with string (associative) keys, not just numerically indexed arrays."}

{"answer": "no", "explanation": "PHP 8.1 allows combining named arguments with unpacking (e.g., foo(a: 1, ...$args)), as long as there are no duplicate values."}

{"answer": "no", "explanation": "In PHP, anonymous functions (closures) are isolated from the outer scope and cannot access outer variables unless they are explicitly imported using the use keyword."}

```json ⏎ {"answer": "3", "explanation": "func_num_args() returns the total number of arguments passed to the function, and f(1, 2, 3) passes 3 arguments."} ⏎ ```

{"answer": "false", "explanation": "Arrow functions (fn) in PHP have a body consisting of exactly one expression that is implicitly returned, and do not support multiple statements in curly braces."}

{"answer": "no", "explanation": "Arrow functions in PHP capture outer variables by value (implicitly), not by reference, so changes to the outer variable after creation do not affect the already-captured value."}

{"answer": "yes", "explanation": "A static closure in PHP is unbound and therefore cannot capture $this, unlike a non-static closure created within a class scope which does capture $this."}

{"answer": "5", "explanation": "The closure captures $x by value at the time it is defined (when $x is 5), so subsequent changes to $x do not affect it."}

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

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

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

{"answer": "yes", "explanation": "In PHP, declaring a method with the final keyword prevents it from being overridden by any subclass, and attempting to do so throws an error."}

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

{"answer": "Class@anonymous", "explanation": "Anonymous classes receive a generated name of the form 'Class@anonymous' + file path + NUL byte + random hex suffix, so stripping the file path leaves the static prefix 'Class@anonymous'."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, private methods are not part of the inheritance contract and cannot be overridden, so a child class is free to declare a method with the same name and any visibility without any conflict."} ⏎ ```

{"answer": "no", "explanation": "__get() is invoked for reading data from inaccessible properties (non-existent OR non-public/private ones), not only for non-existent properties."}

{"answer": "Error", "explanation": "In PHP 8.1+, reassigning a readonly property after initialization throws an Error (specifically a ValueError-like Error), not a standard Exception."}

{"answer": "yes", "explanation": "In PHP 7.1 and later, interfaces can declare constants with actual values, whereas earlier versions only allowed declaring constant names."}

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

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces are allowed to declare static methods that can be called using the :: syntax."}

{"answer": "no", "explanation": "The instanceof operator checks both class inheritance and interface implementation."}

{"answer": "yes", "explanation": "Since PHP 8.0, interface methods can use the 'default' keyword to provide a default implementation, similar to trait methods."}

{"answer": "yes", "explanation": "In PHP, an abstract method can be declared with any visibility (public, protected, or private), so a protected abstract method is valid."}

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

{"answer": "yes", "explanation": "PHP traits can declare constants, properties, and methods, which are then imported into the class that uses the trait."}

{"answer": "yes", "explanation": "In PHP 7 and later, the Throwable interface is the base interface for both Exception and Error classes, allowing them to be caught together."}

{"answer": "no", "explanation": "TypeError extends Error, not Exception, so a catch(Exception $e) block will not catch it; both Error and Exception are separate implementations of Throwable."}

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

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError, which is a PHP 7 exception that extends ArithmeticError and Error."}

{"answer": "false", "explanation": "The finally block always executes regardless of whether an exception was thrown, caught, or re-thrown."}

{"answer": "no", "explanation": "An exception thrown inside a finally block will propagate and override the current result or exception from the try block, so it does affect the outcome."}

{"answer": "yes", "explanation": "Casting any object to boolean in PHP returns true by default unless the object defines a __bool() magic method, and Exception does not define one."}

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

{"answer": "false", "explanation": "The `use` statement only creates a namespace alias for the class name; it does not load the file, which is done by PHP's autoloader when the class is actually referenced."}

{"answer": "function", "explanation": "In the context being referenced, importing a function (as opposed to a class) uses the word 'function', while a class would use 'class'."}

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

{"answer": "yes", "explanation": "Composer's vendor/autoload.php requires autoload_real.php, which registers the classmap, PSR-4, and files autoloaders through spl_autoload_register()."}

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

{"answer": "no", "explanation": "In PHP, an unqualified class name in a `new` expression is resolved relative to the current namespace, not the global root, unlike functions and constants which do fall back to global scope."}

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

```json ⏎ {"answer": "yes", "explanation": "In PHP, a 'use' statement can be placed inside a function body to locally import a class, function, or constant, and that import is scoped to that function only."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, arrays are value types that are copied on assignment (using copy-on-write semantics) unless explicitly passed by reference with &."}

```json ⏎ {"answer": "2", "explanation": "Arrays in PHP are value types, so `$b = $a` creates an independent copy; modifying `$b` does not affect `$a`, which still has 2 elements."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, user-defined globals are function-local by default, so accessing them inside a function requires the `global` keyword, the `$GLOBALS` array, or passing them as parameters (though built-in superglobals remain accessible)."}

{"answer": "no", "explanation": "unset($GLOBALS['x']) removes the global variable entirely and permanently, not just within the current function's scope, because it deletes the key from the $GLOBALS superglobal array which holds the actual global variable."}

{"answer": "6", "explanation": "The inc() function takes $x by reference and increments it, so $n changes from 5 to 6 before being echoed."}

{"answer": "no", "explanation": "When iterating a foreach by value, PHP works on a copy of the array's internal state, so modifications inside the loop are not visible during the same pass; you need foreach by reference (&$value) for that."}

{"answer": "no", "explanation": "A static property belongs to the class itself and is shared across all instances, so changes made through one instance are visible in others."}

{"answer": "no", "explanation": "In PHP, boolean array keys are cast to integers, so `true` becomes the key `1` and `false` becomes `0`, not stored as a bool."}

{"answer": "yes", "explanation": "In PHP (since 7.0), a generator can use `return $value;` and the returned value is retrieved via the Generator's `getReturn()` method."}

{"answer": "yes", "explanation": "A fully consumed generator has not been closed, so calling rewind() resets its execution to the start and allows it to be traversed again, producing the same sequence of values."}

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

{"answer": "Generator", "explanation": "A function containing a yield statement is a generator function, so calling g() returns a Generator object, and get_class returns its class name as the string \"Generator\"."}

{"answer": "3", "explanation": "The generator yields the 3 elements from [1, 2, 3], iterator_to_array converts them to an indexed array, and count returns 3."}

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

```json ⏎ {"answer": "yes", "explanation": "ArrayIterator is a PHP SPL class that wraps an array and implements the Iterator interface (along with ArrayAccess, Countable, and others) to allow traversal."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "ArrayObject implements the Iterator interface, so it CAN be traversed with foreach."} ⏎ ```

{"answer": "yes", "explanation": "password_hash() automatically generates a random salt for you, so providing one separately is unnecessary and discouraged."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT uses bcrypt (PASSWORD_BCRYPT) as the default hashing algorithm in PHP 8, not md5."}

{"answer": "yes", "explanation": "password_verify returns true when the provided password matches the hashed password, and since 'secret' matches the hash of 'secret', it returns true (yes)."}

{"answer": "no", "explanation": "strip_tags() only removes HTML and PHP tags, so it helps against XSS but provides no protection against SQL injection, which requires parameterized queries or escaping."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID upon login, which invalidates any previously fixed session ID and prevents session fixation attacks."}

```json ⏎ {"answer": "php_sapi_name()", "explanation": "The built-in function php_sapi_name() returns the name of the SAPI (Server API Interface) that the script is running under, such as \"cli\" or \"apache2handler\"."} ⏎ ```

{"answer": "yes", "explanation": "session_destroy() only deletes the server-side session data, not the session cookie stored in the user's browser, which would need to be manually unset via setcookie() with an expired timestamp."}

{"answer": "false", "explanation": "The $_SESSION array is only populated with session data after session_start() is called to initialize the session."}

{"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3 as part of a set of array functions including array_find_key(), array_map(), array_filter(), and array_slice()."}

```json ⏎ {"answer": "yes", "explanation": "Property hooks (get/set) were indeed introduced in PHP 8.4, allowing custom get/set/plus/etc. logic directly within property declarations."} ⏎ ```

{"answer": "yes", "explanation": "Asymmetric visibility, allowing properties like `public private(set)`, was indeed introduced in PHP 8.4."}

{"answer": "8.2", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2 to allow marking return values whose discard should trigger a warning."}

```json ⏎ {"answer": "8.1", "explanation": "The pipe operator |> was introduced in PHP 8.1 (2021), allowing values to be passed as the last argument to a function."} ⏎ ```

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

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

```json ⏎ {"answer": "8.5", "explanation": "The Partial Function Application RFC v2 was adopted and targeted for PHP 8.5."} ⏎ ```

{"answer": "8.5", "explanation": "The clamp() function was implemented in PHP 8.5 following the adoption of the clamp_v2 RFC."}

```json ⏎ {"answer": "no", "explanation": "The Context Managers RFC proposal was rejected/withdrawn and never adopted into PHP."} ⏎ ```

{"answer": "no", "explanation": "PHP's \"Bounded-Erased Generics\" RFC was accepted (not declined) in 2024, and generics were implemented, so the claim that it was declined in 2026 is false."}

{"answer": "no", "explanation": "The RFC to make ZTS the default in PHP was proposed and debated but was ultimately not accepted/passed."}

{"answer": "yes", "explanation": "Generics/parameterized types remain unimplemented in PHP through version 8.5, as the proposal has not yet been adopted."}

{"answer": "yes", "explanation": "PHP follows an annual release cycle (feature releases in November), so PHP 8.5 would be stable by late 2025 and PHP 8.6 would not be GA until around November 2026."}

{"answer": "yes", "explanation": "The PHP 6 branch, which was developed for Unicode support, was never officially released; PHP 5.6 was followed directly by PHP 7.0."}

{"answer": "false", "explanation": "The RFC proposing the #[\\Deprecated] attribute was discussed but ultimately rejected (not adopted), as the community decided existing deprecation mechanisms were sufficient."}

{"answer": "yes", "explanation": "In clean and onion architecture, dependencies must point inward, so inner layers never reference outer layers, keeping business rules independent of external concerns."}

{"answer": "yes", "explanation": "In Domain-Driven Design, domain entities should be pure business objects that depend only on the PHP language and standard library, staying decoupled from infrastructure concerns like Doctrine (ORM) and Symfony, which belong to outer layers."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation/view layer, not the business-logic layer; use cases constitute the business-logic layer, and the presentation layer calls them."}

{"answer": "Domain entities", "explanation": "In onion architecture, the innermost core contains the domain entities and business rules that are independent of any framework or infrastructure."}

{"answer": "yes", "explanation": "Deptrac analyzes code dependencies between layers and fails the build when a forbidden cross-layer call is detected, so layer boundary violations are caught automatically rather than at runtime."}

{"answer": "no", "explanation": "Use cases (interactors) belong to the inner domain layer and must accept domain-level inputs (value objects, DTOs, entities), not framework-specific objects like HTTP requests or an EntityManager, because doing so would couple the business logic to persistence/transport concerns and break testability and layering."}

{"answer": "Repository", "explanation": "In Domain-Driven Design, a Repository provides a collection-like interface for accessing aggregates/entities while abstracting the underlying storage mechanism."}

{"answer": "yes", "explanation": "In clean architecture, the database is an outer-layer implementation; the port interfaces are defined in inner layers, so swapping databases only requires changing the outer adapter while the domain and use cases remain unchanged."}

{"answer": "no", "explanation": "An aggregate in Domain-Driven Design is a cluster of entities and value objects treated as a unit for change purposes, which is a domain modeling concept, not a database table."}

{"answer": "yes", "explanation": "Value objects are immutable and are defined by their field values rather than a distinct identity, so two value objects with equal fields are considered equal regardless of object identity."}

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

{"answer": "yes", "explanation": "In DDD, repositories manage aggregate roots, and entities inside an aggregate are accessed only through the root, so you do not create a separate repository for each entity."}

{"answer": "yes", "explanation": "Ubiquitous language in Domain-Driven Design is the shared, consistent vocabulary developed collaboratively by developers and domain experts that models the domain."}

```json ⏎ {"answer": "Tarski's boundary", "explanation": "This refers to the conceptual boundary in Tarski's semantics within which a model and its language remain consistent, beyond which the same words denote different models."} ⏎ ```

{"answer": "false", "explanation": "DDD specifically rejects the anemic domain model as an anti-pattern; Eric Evans advocates for a rich domain model where objects encapsulate both state and behavior rather than holding only getters/setters with logic pushed into services."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a bounded context defines the boundary within which a model applies, and the same concept can legitimately be modeled differently in different contexts, requiring separate classes."}

{"answer": "yes", "explanation": "Symfony's DI container uses lazy instantiation by default, meaning services are only instantiated when first requested rather than all at once at container compile time."}

{"answer": "debug:router", "explanation": "The Symfony console command `debug:router` displays all registered routes along with their details."}

```json ⏎ {"answer": "no", "explanation": "Symfony autowiring automatically injects dependencies based on type-hints and, by default, autoconfigures services, so you don't need to manually declare every service in services.yaml."} ⏎ ```

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes and caches them to disk so subsequent requests load the cached bytecode instead of recompiling."}

{"answer": "yes", "explanation": "In the dev environment, Symfony records the modification times of tracked definition files and only regenerates the container when those files change, rather than rebuilding on every request."}

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

```json ⏎ {"answer": "no", "explanation": "Symfony's ControllerResolver rejects non-public methods because controllerIsCallable() requires is_callable() to return true (which fails for private/protected methods from outside the class) plus an isPublic() reflection check, so only public methods can act as controllers."} ⏎ ```

{"answer": "no", "explanation": "Event priority depends on the numeric priority value passed to addSubscriber/addListener, not on whether the handler is a subscriber or a listener."}

{"answer": "yes", "explanation": "The old Guard-based authentication system was deprecated in Symfony 5.0 and completely removed in Symfony 6.0, leaving the new AuthenticatorInterface-based system."}

```json ⏎ {"answer": "IsGranted", "explanation": "The #[IsGranted] attribute checks whether the user holds a specific role or permission on a controller method, throwing an AccessDeniedException (resulting in a 403 response) if the check fails."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Voters are indeed Symfony's mechanism for authorizing access to specific objects (subjects), and isGranted('EDIT', $post) demonstrates a voter checking access against a $post object as the subject."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony 7 the doctrine/annotations dependency was removed, so validation constraints must be declared via PHP attributes and annotation syntax is no longer supported."}

{"answer": "yes", "explanation": "Symfony enables CSRF protection by default for forms via the csrf_protection option, automatically adding a token field and validating it on submission."}

{"answer": "yes", "explanation": "Symfony's form validation always executes server-side, so it remains enforced regardless of whether browser-side HTML5 validation passed, since client-side checks are unreliable and should never be trusted."}

```json ⏎ {"answer": "make:form", "explanation": "The Symfony MakerBundle provides the `make:form` command, which scaffolds a form class (FormType) based on a class name and the fields you specify."} ⏎ ```

{"answer": "no", "explanation": "Symfony never stores passwords in the session (or anywhere in plain text); it stores only the user identifier after the password is verified and hashed in storage."}

{"answer": "yes", "explanation": "In Symfony, bundle and topic configurations are typically organized as individual files (YAML, XML, or PHP) inside the config/packages/ directory."}

```json ⏎ {"answer": "yes", "explanation": "This is the standard DotEnv pattern: the committed .env file contains development defaults that are safe to share, while .env.local holds real secrets, is listed in .gitignore, and is never committed."} ⏎ ```

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

```json ⏎ {"answer": "no", "explanation": "The compiled Symfony container is frozen after compilation, so calling setParameter() on it throws a RuntimeException and cannot change parameters at runtime."} ⏎ ```

{"answer": "no", "explanation": "By default, Symfony services are private (public: false) and should be accessed through dependency injection rather than fetched directly from the container."}

{"answer": "no", "explanation": "Bundles can work with their built-in default configuration, so a config file in config/packages is not mandatory."}

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

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

{"answer": "no", "explanation": "In Symfony Messenger, a single message type can be handled by multiple handlers, as handlers are registered by message class and multiple can listen to the same message."}

```json ⏎ {"answer": "no", "explanation": "The sync transport processes the message immediately during dispatch, whereas only the async transport queues messages for a worker to consume."} ⏎ ```

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

{"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy (max_retries, delay, multiplier, etc.) is configured within each transport's configuration, making it a per-transport setting."}

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

{"answer": "no", "explanation": "Symfony Scheduler schedules and runs tasks (commands, closures, signals) on a cron-based schedule via SchedulerEventSubscriber, but it does not produce or dispatch messages through the Messenger component."}

{"answer": "Doctrine", "explanation": "The Doctrine transport stores messages in database tables using the Doctrine ORM/DBAL connections."}

{"answer": "yes", "explanation": "In Symfony's Messenger component, the middleware chain (pipeline) can be extended with custom middleware, whose execution order relative to the built-in ones is controllable via configuration."}

{"answer": "yes", "explanation": "Symfony follows this release cycle where major versions are released every two years and minor feature releases come out every six months in May and November."}

{"answer": "8.3", "explanation": "Symfony 8.0, scheduled for release in November 2026, is expected to require PHP 8.3 or higher as its minimum version, continuing the trend of Symfony requiring increasingly recent PHP versions."}

{"answer": "false", "explanation": "Symfony 7.0 removed support for doctrine/annotations, so validation and routing metadata must now be defined using PHP attributes instead of docblock annotations."}

{"answer": "yes", "explanation": "Symfony's AssetMapper manages CSS/JS assets directly in the browser via importmap.php, eliminating the need for Node.js, npm, or webpack."}

```json ⏎ {"answer": "no", "explanation": "Symfony 6.4 is actually a Long-Term Support (LTS) release, not a regular release."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Symfony's deprecation policy keeps deprecations introduced in a minor version active for at least 2 major versions before removing them, so upgrading to a new major version doesn't immediately remove the previous branch's deprecations."} ⏎ ```

{"answer": "yes", "explanation": "Symfony's release process requires that every major release includes an UPGRADE guide documenting the breaking changes and migration steps for developers."}

{"answer": "Symfony Component Asset", "explanation": "The Asset component (with its importmap feature) manages JavaScript/CSS assets and importmaps directly without requiring Node.js or Webpack."}

{"answer": "no", "explanation": "Symfony 8.0 would be released in November 2026, so version 8.2 cannot exist yet as of 2026-11-07."}

{"answer": "no", "explanation": "Symfony 8.0 is scheduled for November 2026, so version 8.2 would follow in November 2027, not November 2026."}

{"answer": "8.2", "explanation": "Symfony follows a major.minor versioning scheme with releases every six months, so 8.2 is the version that follows 8.1."}

{"answer": "no", "explanation": "Symfony 8.2 is a point release within the 8.x major version line, not a new major release, so it follows minor release conventions and does not require a full application rewrite."}

{"answer": "yes", "explanation": "PHP maintains backward compatibility within a major version's minor releases, so upgrading from 8.1 to 8.2 generally does not break existing code (though some features may be deprecated and emit warnings)."}

{"answer": "8.4", "explanation": "Symfony follows a pattern where each major version branch gets minor releases numbered 0 through 4 before the next major version, so the final 8.x release before 9.0 is 8.4."}

{"answer": "no", "explanation": "Symfony 8.x requires PHP 8.2 or higher as its minimum, so Symfony 8.2 does not require PHP 8.5."}

```json ⏎ {"answer": "yes", "explanation": "Symfony's LTS policy for the 8.x branch ensures that any deprecations introduced there will not be removed until Symfony 9.0, providing a long migration window."} ⏎ ```

{"answer": "no", "explanation": "Inside Twig's {{ }} you can only evaluate and print expressions, not execute arbitrary PHP code, which requires the {% %} syntax for statements."}

```json ⏎ {"answer": "yes", "explanation": "Twig enables auto-escaping by default, which means variables printed with {{ }} are automatically escaped based on the current context (e.g., HTML, JavaScript, CSS)."} ⏎ ```

{"answer": "yes", "explanation": "The Twig |e filter escapes a string using the HTML escaping strategy by default, making it safe for output in HTML contexts."}

{"answer": "format_number", "explanation": "The `format_number` filter in Twig's intl-extra component formats a number according to a specified locale using the NumberFormatter class."}

{"answer": "yes", "explanation": "The |raw filter in Twig marks a value as safe, preventing it from being auto-escaped by the template engine."}

{"answer": "yes", "explanation": "In Twig, {{ }} is the output tag for printing expression values, while {% %} contains control tags like if, for, and set that execute logic without printing."}

```json ⏎ {"answer": "no", "explanation": "Twig allows you to declare variables inside templates using the set tag, such as {% set foo = 'bar' %}."} ⏎ ```

{"answer": "dump", "explanation": "The Twig dump() function dumps the debug structure (representing arrays and objects) of the passed variables, similar to PHP's var_dump()."}

{"answer": "yes", "explanation": "Bootstrap provides ready-made CSS and JavaScript UI components (like navbars, cards, and modals) and is not an SPA framework like React or Vue."}

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

{"answer": "no", "explanation": "Bootstrap's grid is based on 12 columns (not 16) and modern Bootstrap versions (4+) use Flexbox rather than CSS floats."}

{"answer": "yes", "explanation": "Bootstrap 5 defines five named breakpoints with infixes sm, md, lg, xl, and xxl, corresponding to minimum viewport widths of 576, 768, 992, 1200, and 1400px respectively."}

```json ⏎ {"answer": "yes", "explanation": "Bootstrap's spacing utilities are generated from the $spacers scale, which is derived from the $spacer variable, so class suffixes map to values that are multiples of that base spacer unit."} ⏎ ```

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the `data-bs-toggle` attribute (e.g., `data-bs-toggle=\"dropdown\"`) is used to activate/enable interactive components like dropdowns, modals, and tooltips on an element."}

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

{"answer": "yes", "explanation": "In Bootstrap 5.3+, dark mode is enabled by adding the .dark class to the root element (typically the <html> tag), which applies CSS variables for the dark color scheme."}

{"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; you must explicitly run the schema tool (e.g., 'doctrine:schema:create') to generate the database schema from your entity metadata."}

{"answer": "persist()", "explanation": "The EntityManager::persist() method marks a new object as managed, deferring SQL execution until flush() is called."}

{"answer": "no", "explanation": "Doctrine ORM 3 removed the deprecated EntityManager::merge() method (deprecated in 2.14, removed in 3.0), so it does not exist."}

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

{"answer": "null", "explanation": "Doctrine's repository->find() method returns null when no entity with the given identifier exists in the database."}

{"answer": "no", "explanation": "Doctrine requires an explicit flush() call to persist changes to the database; Symfony does not automatically flush at the end of the request."}

{"answer": "yes", "explanation": "Once an entity is managed, Doctrine's Unit of Work performs dirty checking during flush() and automatically detects and commits property changes without requiring an explicit persist()."}

```json ⏎ {"answer": "no", "explanation": "In Doctrine ORM, remove() only schedules the entity for deletion and defers the actual SQL DELETE until flush() is called to synchronize the unit of work."} ⏎ ```

{"answer": "false", "explanation": "PostgreSQL's MVCC specifically allows readers and writers to run concurrently without blocking each other, since readers see a consistent snapshot of old data while writers write new versions."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command (also EXPLAIN ANALYZE in PostgreSQL or EXPLAIN PLAN in Oracle) displays the execution plan a query would use without actually running it."}

```json ⏎ {"answer": "no", "explanation": "SERIAL and GENERATED ... AS IDENTITY both use sequences but are distinct mechanisms with different behavior regarding column ownership, ALTER TABLE, and COPY operations."} ⏎ ```

{"answer": "no", "explanation": "In PostgreSQL, a UNIQUE constraint allows multiple NULL values because NULLs are treated as distinct from one another, so you can have more than one row with NULL in the constrained column."}

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

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

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

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

{"answer": "yes", "explanation": "By default PostgreSQL runs in autocommit mode, so each standalone SQL statement is executed in its own implicit transaction that is automatically committed on success."}

{"answer": "COMMIT", "explanation": "The COMMIT command saves and ends the current transaction by persisting all its changes to the database."}

{"answer": "yes", "explanation": "Indexes speed up UPDATE and DELETE operations too, because a WHERE clause searching on an indexed column allows the database to quickly locate the target rows instead of scanning the entire table."}

{"answer": "yes", "explanation": "In PostgreSQL, SAVEPOINT lets you mark a point within a transaction that can be rolled back to using ROLLBACK TO SAVEPOINT, allowing only part of the transaction to be undone while the rest continues."}

```json ⏎ {"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports actual runtime timing, whereas plain EXPLAIN shows only the plan without executing it."} ⏎ ```

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

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

{"answer": "no", "explanation": "PostgreSQL's SERIALIZABLE isolation level uses Serializable Snapshot Isolation (SSI), which detects serialization failures and aborts transactions rather than locking the rows it reads."}

{"answer": "yes", "explanation": "HTTP 201 'Created' is a success status indicating that the request resulted in a new resource being created."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates the request succeeded but there is no body to return, which is typical for DELETE operations."}

{"answer": "yes", "explanation": "The HTTP specification classifies DELETE as an idempotent method, meaning repeated identical DELETE requests produce the same resource state as a single request."}

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

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

{"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 body of an HTTP request or response."}

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

{"answer": "no", "explanation": "Using plain == for hash comparison is not sufficient because it is vulnerable to timing attacks; you should use the timing-safe hash_equals() function instead."}

{"answer": "yes", "explanation": "A CSRF token is generated by the server, associated with the user's session, and embedded in forms, then validated server-side on state-changing requests like POST, PUT, or DELETE to ensure the request originated from a legitimate source."}

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

```json ⏎ {"answer": "no", "explanation": "OAuth 2.0 is an authorization framework that grants access, not an authentication protocol, and an access token authorizes access rather than identifying who the user is (that's what OpenID Connect provides)."} ⏎ ```

{"answer": "no", "explanation": "XSS is prevented by encoding/escaping output when rendering data in the browser, not by merely validating or storing input, since stored data still needs to be safely encoded upon display."}

{"answer": "authorization_code", "explanation": "In the OAuth 2.0 authorization code flow, the authorization server redirects to the redirect_uri with an authorization_code parameter, which the client then exchanges for an access token."}

{"answer": "yes", "explanation": "Refresh tokens are designed to outlive access tokens and are used to obtain new access tokens via the OAuth 2.0 refresh flow without requiring reauthentication."}

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

{"answer": "no", "explanation": "In modern PHPUnit, a class must extend PHPUnit\Framework\TestCase (or use its attributes) for PHPUnit to recognize and run its test methods."}

{"answer": "no", "explanation": "setUp() runs before EACH test method, not once for the whole class, while setUpBeforeClass() runs once before all tests."}

{"answer": "no", "explanation": "A data provider can return multiple data sets, allowing a test to run repeatedly with different arguments, not just one."}

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

{"answer": "no", "explanation": "The statement is reversed: in PHPUnit a stub provides canned return values while a mock verifies that specific methods were called with expected arguments."}

{"answer": "yes", "explanation": "In PHPUnit 10, metadata annotations like @dataProvider were deprecated in favor of native PHP attributes like #[DataProvider], which is the recommended approach going forward."}

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

{"answer": "--order-by=random", "explanation": "PHPUnit uses the `--order-by=random` option to shuffle the execution order of tests, and `--random-order-seed` can set a specific seed for reproducibility."}

{"answer": "3-3", "explanation": "intdiv(7,2) returns 3 (truncated toward zero) and intdiv(-7,2) returns -3 (also truncated toward zero), which are concatenated to form '3-3'."}

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

{"answer": "true", "explanation": "'1e1' is a numeric string in scientific notation equal to 10, so PHP performs a numeric comparison where 10 equals 10, making the result true."}

{"answer": "zero", "explanation": "The string 'a' loosely equals 0 because a non-numeric string converts to 0, so it matches case 0."}

```json ⏎ {"answer": "2c", "explanation": "With an associative array, strtr finds the longest matching key, so 'ab' matches and becomes '2', leaving 'c' unchanged."} ⏎ ```

{"answer": "[hello]", "explanation": "In PHP 8.0+, when the negative offset's absolute value exceeds the string length, substr() returns the whole string, so substr('hello', -10) yields 'hello', resulting in '[hello]'."}

{"answer": "k,n,m", "explanation": "The + operator unions arrays with left operand's keys taking precedence, so $a+$b gives ['k'=>1,'n'=>2,'m'=>3], and array_keys preserves insertion order."}

```json ⏎ {"answer": "yxz", "explanation": "usort sorts ascending by the third column keeping stable order for equal values (y=1, x=2, z=2), and array_column extracts the second column to yield y,x,z."} ⏎ ```

{"answer": "4", "explanation": "The spread operator with an associative array matches keys to parameter names, so 'a' => 5 and 'b' => 1 are passed by name regardless of order, giving 5 - 1 = 4."}

```json ⏎ {"answer": "3", "explanation": "The `$p->g(...)` first-class callable syntax creates a closure bound to the instance of P (capturing the object by value), and since g() is public it returns the private value 3 even after the local variable $p is set to null."} ⏎ ```

{"answer": "B", "explanation": "The who() method uses static::class which relies on late static binding, so calling it on a B instance returns the class B."}

{"answer": "Fatal error (infinite recursion)", "explanation": "The set hook assigns to $this->x, which re-invokes the same set hook, causing infinite recursion that crashes PHP rather than outputting 10."}

{"answer": "BA", "explanation": "TB::f insteadof TA makes f() return 'B', while TA::f as g aliases TA's f so g() returns 'A', giving 'BA'."}

{"answer": "0", "explanation": "In PHP, each class using a trait with a static property gets its own separate copy of that static property, so setting CX::$n to 1 does not affect CY::$n which remains 0."}

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

{"answer": "second", "explanation": "The inner try throws RuntimeException, but the finally block runs and throws LogicException 'second' which overrides the original exception and is caught by the outer catch, echoing 'second'."}

```json ⏎ {"answer": "App\\Foo|Baz", "explanation": "Inside namespace N, Baz::class resolves to the imported App\\Foo, while \\Baz::class refers to the fully-qualified (global) class name Baz, and ::class always yields the FQN string without requiring the class to exist."} ⏎ ```

{"answer": "yesyes", "explanation": "class_exists('Foo') resolves to the namespaced Ns\\Foo which exists, and class_exists('Ns\\Foo') is the fully qualified name which also exists, so both conditions are true."}

```json ⏎ {"answer": "1,2,99", "explanation": "The foreach loop's reference variable $v stays bound to the last array element ($a[2]) after the loop, so $v = 99 overwrites $a[2], yielding [1,2,99]."} ⏎ ```

{"answer": "3", "explanation": "Static variable $n is scoped to the declaring class A, and since B does not override inc(), all calls use A's shared static $n, which gets incremented to 1, then 2, then outputs 3."}

{"answer": "Fatal TypeError (no output)", "explanation": "The first send(10) only drives the generator to its first yield (returning 1, which is discarded), so the generator is still paused and not completed; calling getReturn() on an incomplete Generator throws a TypeError instead of printing a value."}

```json ⏎ {"answer": "1,2,ok", "explanation": "The `yield from inner()` forwards inner's yielded values 1 and 2, then the return value 'ok' is captured in $r and subsequently yielded, producing the array [1, 2, 'ok'] which implode joins to '1,2,ok'."} ⏎ ```

```json ⏎ {"answer": "noyes", "explanation": "The first check uses cost 4 matching the hash so it doesn't need rehashing (returns 'no'), while the second checks cost 5 which differs from the stored cost 4, requiring a rehash (returns 'yes')."} ⏎ ```

{"answer": "strict-in", "explanation": "2048 is E_STRICT, which remains a bit set within E_ALL in PHP 8.x, so E_ALL & 2048 is non-zero (2048), making the ternary select 'strict-in'."}

{"answer": "missing", "explanation": "The header is stored in $_SERVER as HTTP_X_TOKEN and Symfony's HeaderBag normalizes it to the key 'http_x_token' without stripping the HTTP_ prefix, so get('X-Token') returns null."}

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

```json ⏎ {"answer": "same", "explanation": "Doctrine's EntityManager maintains a first-level identity map, so both find() calls return the same entity instance ($u) that was persisted, making their spl_object_id values equal."} ⏎ ```

{"answer": "0", "explanation": "Persisting then immediately removing a new (unpersisted) entity cancels out in Doctrine's UnitOfWork, so flush executes no SQL and the empty table stays empty."}

```json ⏎ {"answer": "1", "explanation": "count(x) counts only non-NULL values of x, so the single row with x=1 is counted while the NULL row is ignored."} ⏎ ```

{"answer": "10,30,60", "explanation": "The subquery computes a running total of x ordered by id (10, 30, 60), and string_agg concatenates these values with a comma separator ordered by id."}

{"answer": "M1M2", "explanation": "The MessageBus runs the middlewares in array order, so the outermost Trace('M1') echoes 'M1' first, then delegates to Trace('M2') which echoes 'M2', producing 'M1M2' (an uncaught LogicException may follow when the innermost next() call has nothing left, but the echoed output is 'M1M2')."}

{"answer": "11", "explanation": "The HandleMessageMiddleware loops over all handlers returned by HandlersLocator::getHandlers() for the message class without breaking, so both `$d1` ($n += 1) and `$d2` ($n += 10) execute, giving $n = 11."}

{"answer": "1", "explanation": "The first INSERT adds the value 1, and the second INSERT conflicts with the unique index so it is skipped, leaving one row in the table."}

{"answer": "2", "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, its check is postponed until transaction end (COMMIT), so both INSERTs of value 1 succeed and are visible to the SELECT which runs before any COMMIT, returning 2."}

```json ⏎ {"answer": "6", "explanation": "The `--filter test_sum` uses a regex without end-anchoring, so it matches both `test_sum` and `test_sum_abs` (each with 3 data-provider cases = 6 tests), while `test_other` does not match."} ⏎ ```

```json ⏎ {"answer": "2, 1", "explanation": "The data provider supplies two cases ([1] and [-1]), so 2 tests run; the case with -1 fails the assertTrue check."} ⏎ ```

```json ⏎ {"answer": "POST", "explanation": "The -d/--data option makes curl send an HTTP POST request with the data as the request body."} ⏎ ```

{"answer": "GET", "explanation": "The `-d` flag normally sends POST data, but the `-G` flag redirects that data to the query string, converting the request to a GET method."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, when the client_id is non-existent, client authentication fails, so the endpoint returns the error value 'invalid_client' rather than revealing details about the missing client."}

{"answer": "fragment (hash)", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access_token is returned in the URL fragment (the part after the #), not the query string, to avoid sending it to the server."}

{"answer": "6", "explanation": "The default filter replaces the falsy `false` with `2`, and since multiplication binds at least as tightly as the filter, the result is `2 * 3 = 6`."}

{"answer": "Twig\\Error\\RuntimeError", "explanation": "Because concatenation (~) binds tighter than (+), Twig evaluates ('a' ~ 1) + 2, i.e. 'a1' + 2, and PHP's E_WARNING for adding a non-numeric string is converted by Twig's registered error handler into a Twig\\Error\\RuntimeError."}

{"answer": "0", "explanation": "The value being validated is the non-empty array `['']`, and `NotBlank` allows arrays (checking `0 !== count($value)`), so no violation is produced and `count()` of the resulting empty `ConstraintViolationList` is 0."}

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

```json ⏎ {"answer": "same", "explanation": "Symfony DI services are singletons by default, so both get() calls return the same cached stdClass instance, making their spl_object_id values equal."} ⏎ ```

{"answer": "hi Bob!", "explanation": "The ContainerBuilder resolves nested parameter placeholders recursively at getParameter time, so '%greeting'%' becomes 'hi %name'%' which becomes 'hi Bob'!"}

{"answer": "960px", "explanation": "In Bootstrap 5.3, the .container class applies the breakpoint at and above 992px (lg), where the defined max-width is 960px."}

{"answer": "text-danger", "explanation": "Both text-danger and text-primary set the same 'color' property with equal specificity, so the class that appears later in Bootstrap 5.3's generated stylesheet (text-danger follows text-primary in the theme-colors map) wins."}

{"answer": "2", "explanation": "The OrderService is in the Domain layer, which only depends on Domain, but it imports PlaceOrder (Application) and Db (Infrastructure), producing 2 violations."}

{"answer": "3", "explanation": "The class is in the Domain layer, which may only depend on Domain, but it imports App\\Application\\PlaceOrder (Application), App\\Infrastructure\\Db (Infrastructure), and App\\Infrastructure\\Logger (Infrastructure), each counting as one forbidden dependency edge."}

{"answer": "10,15", "explanation": "$a->amount is 10 and $c->amount is the result of adding 5 to 10, which is 15, so the output is \"10,15\"."}

{"answer": "1", "explanation": "The remove() method throws a DomainException because there's exactly one item before removal, which prevents the unset from executing, so count() still returns 1."}

```json ⏎ {"answer": "hi", "explanation": "The code creates a new instance of C and immediately calls hi(), which returns the string 'hi', so it echoes 'hi'."} ⏎ ```

```json ⏎ {"answer": "yes\nno", "explanation": "The lazy ghost's initializer callback (which sets $obj->v = 21) runs only when the property $o->v is first accessed, so it reports 'yes' before access and 'no' after."} ⏎ ```

{"answer": "no", "explanation": "The Symfony Security Guard component (including AbstractGuardAuthenticator) was deprecated in 5.1 and completely removed in 6.0, so the class does not exist in Symfony 8.1."}

{"answer": "noyes", "explanation": "In Symfony 6.0 the deprecated AnnotationClassLoader was removed (so it doesn't exist in 6.4/8.1, giving 'no'), while AttributeClassLoader for PHP 8 attributes remains available (giving 'yes')."}