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

{"answer": "no", "explanation": "Double-quoted strings support variable interpolation and escape sequence processing 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 trigger an undefined variable notice when the operand is undefined."}

{"answer": "ab", "explanation": "PHP's echo statement accepts multiple comma-separated arguments and concatenates them without any separator, outputting 'a' then 'b' as 'ab'."}

{"answer": "yes", "explanation": "Print is a language construct that always returns 1, which allows it to be used inside an expression."}

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

```json ⏎ {"answer": "yes", "explanation": "In PHP, the addition (+) and subtraction (-) operators have higher precedence than the concatenation (.) operator, so concatenation has lower precedence."} ⏎ ```

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

{"answer": "3", "explanation": "Concatenation (.) has higher precedence than addition (+), so it evaluates as ('sum: ' . 2) + 3 = 'sum: 2' + 3, and since 'sum: 2' starts with non-numeric characters it converts to 0, giving 0 + 3 = 3."}

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

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

{"answer": "no", "explanation": "In PHP 8.0, non-numeric strings compared with loose == to a number are not coerced to 0 anymore, so \"abc\" == 0 returns false."}

{"answer": "yes", "explanation": "In PHP, under loose comparison (==), null is treated as equivalent to 0, the empty string, and false simultaneously, so all these comparisons evaluate to true."}

{"answer": "42", "explanation": "When casting a string to int in PHP, the leading numeric portion of the string is extracted, so '42abc' becomes 42."}

{"answer": 10, "explanation": "The + operator forces PHP to evaluate both operands in numeric context, so the string '5' is coerced to the number 5 and 5 + 5 equals 10."}

```json ⏎ {"answer": "no", "explanation": "When cast to string, false becomes an empty string (\"\"), not \"0\"; it's 0 (the integer) that becomes \"0\" when cast to string."} ⏎ ```

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

```json ⏎ {"answer": "no", "explanation": "strrev() reverses a string byte-by-byte, which corrupts multi-byte UTF-8 characters, so it does not correctly reverse UTF-8 strings."} ⏎ ```

{"answer": "yes", "explanation": "str_contains() checks if a substring exists within a string and returns the boolean true when 'world' is found in 'Hello world'."}

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

{"answer": "no", "explanation": "trim() by default strips 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 1+2+1+1+1=6 bytes."}

{"answer": "def", "explanation": "A negative start offset counts from the end of the string, so -3 means start 3 characters from the end, returning 'def'."}

{"answer": "no", "explanation": "ucfirst() returns a new string with the first character capitalized and does not modify the original string because PHP passes strings by value by default."}

{"answer": "yes", "explanation": "Heredoc parses and interpolates variables, whereas nowdoc behaves like single-quoted strings and does not interpolate variables."}

{"answer": "no", "explanation": "sort() sorts an array by values in ascending order and reindexes the array with new sequential integer keys, so it does not preserve the original key-to-value association."}

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

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

```json ⏎ {"answer": "yes", "explanation": "Without a callback, array_filter() removes all falsy elements (false, 0, 0.0, \"\", \"0\", null, empty arrays) from the array, keeping only truthy values."} ⏎ ```

{"answer": "no", "explanation": "By default, array_slice() reindexes the numeric keys starting from 0; you must pass true as the third argument to preserve original keys."}

{"answer": "[20, 30]", "explanation": "array_slice extracts 2 elements starting from offset 1 (index 1), returning values 20 and 30 while preserving original keys."}

{"answer": "2", "explanation": "The PHP `+` operator performs a union where the left array's keys take precedence, so 'a' => 1 stays and only 'b' => 2 is added from the right array, giving 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 added support for the spread operator to preserve string keys when merging arrays, which was previously lost."}

{"answer": "no", "explanation": "PHP 8.1+ allows combining named arguments with unpacking, provided the unpacked array keys are all strings corresponding to parameter names, so they can be used in a single call."}

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

```json ⏎ {"answer": "3", "explanation": "func_num_args() returns the total number of arguments actually passed to the function (3), regardless of the number of declared parameters (1)."} ⏎ ```

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

{"answer": "no", "explanation": "In PHP, arrow functions automatically capture outer variables by value (eagerly at declaration), not by reference or lazily."}

{"answer": "yes", "explanation": "In PHP, declaring a closure as `static` prevents it from capturing the bound `$this` context, making `$this` inaccessible inside it."}

{"answer": "5", "explanation": "The `use ($x)` clause captures the value of $x by value at the moment the closure is created, so it remains 5 regardless of the later reassignment to 7."}

{"answer": "yes", "explanation": "In weak typing mode, PHP coerces scalar types, 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, which allows declaring and initializing properties directly in the constructor parameters using visibility modifiers like 'private'."}

{"answer": "final", "explanation": "The 'final' keyword in PHP prevents a method (or class or property) from being overridden in subclasses."}

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

{"answer": "no", "explanation": "Private properties are only accessible within the class they are declared in and are not inherited or accessible in child classes."}

```json ⏎ {"answer": "\\AnonymousClass#1", "explanation": "get_class() returns the anonymous class's internal name, which is \\AnonymousClass#<n> (the first one being #1), truncated at the NUL byte that terminates the name."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Private methods are not inherited and are excluded from the inheritance contract, so a child class may redeclare a method with the same name using any visibility (public, protected, or private) without error."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "__get() is invoked not only for non-existent properties but also for inaccessible (protected/private) properties accessed from outside their scope."} ⏎ ```

```json ⏎ {"answer": "Error", "explanation": "In PHP 8.1+, reassigning a readonly property after its initial assignment throws an Error (specifically a 'Cannot modify a readonly property' Error, not an Exception)."} ⏎ ```

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

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

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

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

{"answer": "yes", "explanation": "Since PHP 8.0, interface methods can provide a default implementation using a method body, similar to how trait methods work."}

{"answer": "yes", "explanation": "In PHP, abstract methods may be declared with public or protected visibility, so an abstract method can indeed have protected visibility."}

{"answer": "3", "explanation": "Foo::cases() returns an array containing all cases of the enum, which are A, B, and C, giving 3 elements."}

{"answer": "yes", "explanation": "PHP traits can declare constants, along with properties and methods, which can then be used in the classes that use the trait."}

```json ⏎ {"answer": "yes", "explanation": "In PHP 7+, the Throwable interface is the common base for both Exception and Error, with each implementing it."} ⏎ ```

{"answer": "no", "explanation": "TypeError extends Error (not Exception) in PHP 7+, so a catch(Exception $e) block will not catch it; you must catch \\Throwable instead."}

{"answer": "false", "explanation": "The @ operator only suppresses errors (like warnings and notices), not exceptions, which are thrown and can still be caught by try/catch blocks."}

{"answer": "DivisionByZeroError", "explanation": "In PHP, calling intdiv() with a divisor of zero throws a DivisionByZeroError exception, which extends ArithmeticError and Exception."}

{"answer": "no", "explanation": "The finally block always executes regardless of whether an exception occurred or was caught, or even if the try block completed normally."}

{"answer": "no", "explanation": "An exception thrown in a finally block overrides and replaces any exception that was being propagated from the try block, so it does affect the result."}

{"answer": "true", "explanation": "In PHP, all objects are converted to boolean true unless they implement __isset() returning false, and Exception has no such method, so (bool) new Exception('x') yields true."}

{"answer": "yes", "explanation": "Shutdown functions registered via register_shutdown_function() are guaranteed to run when the script exits, including when exit() is explicitly called."}

{"answer": "no", "explanation": "The `use` statement only creates a compile-time alias for a class name within the current namespace; it does not load the file, which happens lazily via autoloading when the class is actually referenced."}

{"answer": "function", "explanation": "Functions are imported using the `function` keyword approach (named/declaration), whereas a value stored in a `const` arrow function is imported by its variable name; the `function` keyword distinguishes a proper function import from a const import."}

```json ⏎ {"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps the App\\ namespace to src/, so the class App\\Controller\\Api\\UserController is located by replacing the namespace separators with directory separators under src/ and appending .php."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Composer's vendor/autoload.php registers multiple autoloaders (class map, PSR-0, PSR-4, and files) via spl_autoload_register()."} ⏎ ```

{"answer": "yes", "explanation": "The __NAMESPACE__ magic constant returns the name of the current namespace, or an empty string when in the global scope."}

{"answer": "no", "explanation": "In PHP, an unqualified class name in a `new` statement is resolved relative to the current namespace, not the global root (only names with a leading backslash resolve from the global root)."}

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

```json ⏎ {"answer": "yes", "explanation": "In PHP (since 5.4), a use statement for namespace importing can be placed inside a function body, where the import is scoped to that function only."} ⏎ ```

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

```json ⏎ {"answer": "2", "explanation": "In PHP, arrays are passed by value, so $b = $a creates an independent copy, and $b[] = 3 modifies only $b, leaving $a with 2 elements."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "In PHP, variables are lexically scoped, so global variables defined outside a function are not accessible inside the function unless imported via the 'global' keyword, accessed through the '$GLOBALS' superglobal array, or passed as function parameters."} ⏎ ```

{"answer": "no", "explanation": "unset($GLOBALS['x']) destroys the actual global variable 'x' for the entire script, not just within the current function's scope."}

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

{"answer": "no", "explanation": "For a by-value foreach, PHP iterates over a copy of the array (copy-on-write), so modifications made inside the loop are not reflected in the current pass; only reference iteration (& $value) affects the original array elements."}

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

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

```json ⏎ {"answer": "yes", "explanation": "In PHP, a generator can use 'return $value;', and the value can be retrieved later via the generator's getReturn() method."} ⏎ ```

{"answer": "no", "explanation": "Once a generator is fully consumed in PHP, calling rewind() throws a 'Cannot rewind a consumed generator' exception because generators are single-use and do not retain their state for re-traversal."}

{"answer": "yes", "explanation": "The `yield from` construct in PHP delegates traversal to another generator, iterable, array, or string by yielding all of its values."}

{"answer": "Generator", "explanation": "A function containing yield returns a Generator object when called, and get_class() returns its class name as the string \"Generator\"."}

{"answer": "3", "explanation": "The generator yields 1, 2, 3 via `yield from`, so iterator_to_array produces a 3-element array and count returns 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (Last In First Out) stack, while FIFO queues are implemented by the SplQueue class."}

{"answer": "yes", "explanation": "ArrayIterator is a built-in PHP class that wraps an array and provides Iterator (along with ArrayAccess and Countable) interface methods to traverse and access its elements."}

{"answer": "no", "explanation": "ArrayObject implements IteratorAggregate and ArrayAccess, so instances can be traversed with foreach just like arrays."}

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

{"answer": "no", "explanation": "PASSWORD_DEFAULT in PHP 8 uses bcrypt (and Argon2id in newer versions), never md5, which is a fast, unsuitable-for-passwords hash algorithm."}

{"answer": "yes", "explanation": "password_verify returns true when the provided password matches the given hash, and since both use the same plaintext 'secret', verification succeeds."}

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

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID upon login, which invalidates any previously fixed session ID that an attacker might have planted, thereby mitigating session fixation attacks."}

{"answer": "php_sapi_name()", "explanation": "php_sapi_name() returns the server API interface (SAPI) name that PHP is running as, such as \"cli\" for the command-line interface."}

{"answer": "yes", "explanation": "session_destroy() removes server-side session data but does not delete the session cookie stored in the browser, which requires explicitly calling setcookie() with an expiration time."}

{"answer": "no", "explanation": "You must call session_start() to initialize the session and populate $_SESSION with stored session data; without it, $_SESSION remains empty."}

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

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

{"answer": "yes", "explanation": "Asymmetric visibility, which allows properties like `public private(set) string $name` to have separate read/write access levels, was introduced in PHP 8.4."}

{"answer": "8.2", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2."}

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

{"answer": "8.2", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) was introduced in PHP 8.2, allowing you to override properties while cloning an object."}

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

{"answer": "8.4", "explanation": "The Partial Function Application RFC (v2) was adopted for PHP 8.4, introducing the ...() arrow syntax for currying functions."}

{"answer": "8.4", "explanation": "The clamp() function, implemented via RFC clamp_v2, was added in PHP 8.4 as of the 2026-11-07 date."}

{"answer": "no", "explanation": "PHP's Context Managers proposal (the 'with' statement) was submitted but declined/deferred and was never adopted, so a 'v2' adoption did not occur."}

{"answer": "false", "explanation": "The 'Bound-Erased Generic Types' generics RFC was accepted for PHP 8.4, not declined in 2026."}

{"answer": "no", "explanation": "The RFC to make ZTS (Zend Thread Safety) the default build has not been accepted in PHP, as enabling it by default would break numerous existing extensions and configurations."}

{"answer": "yes", "explanation": "PHP still does not have native generics/parameterized types implemented as of version 8.5, despite various RFC discussions and proposals."}

{"answer": "yes", "explanation": "PHP 8.5 was released in November 2025 as the current stable version, and PHP 8.6 follows the annual November release cycle with GA scheduled for November 2026, so as of 2026-11-07, 8.5 is the latest stable."}

{"answer": "yes", "explanation": "PHP 6, which was originally planned for Unicode support, was abandoned and development resumed on the 5.x line, so PHP 7.0 released directly after PHP 5.6 in 2015."}

{"answer": "yes", "explanation": "The RFC to add the #[\\Deprecated] attribute to PHP's core was accepted and it was implemented in PHP 8.4."}

```json ⏎ {"answer": "yes", "explanation": "In clean and onion architecture, the dependency rule requires that inner layers know nothing about outer ones, with all source code dependencies pointing inward toward the center."} ⏎ ```

{"answer": "yes", "explanation": "In domain-driven/hexagonal architecture, domain entities must stay pure PHP classes free of framework or persistence dependencies so they remain testable and decoupled from infrastructure."}

```json ⏎ {"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation/presenter layer, not the business-logic layer, since they only orchestrate calls to use cases while the actual business logic resides in the use cases themselves."} ⏎ ```

{"answer": "The domain entities (business rules)", "explanation": "In the onion architecture, the innermost layer at the very center contains the domain entities and general business rules, which are protected from external concerns by surrounding layers."}

{"answer": "yes", "explanation": "Deptrac performs static analysis to detect forbidden cross-layer dependencies and fails the build when such violations occur."}

{"answer": "no", "explanation": "Use cases should be transport- and infrastructure-agnostic, accepting only domain-level inputs (like value objects or DTOs), so they remain testable and decoupled from HTTP or EntityManager concerns."}

{"answer": "Repository", "explanation": "The Repository pattern encapsulates the collection of aggregates/entities and abstracts the storage mechanism behind an interface."}

{"answer": "yes", "explanation": "Clean architecture follows the dependency rule, where inner layers (domain, use cases) are independent of outer infrastructure layers, so swapping databases only requires changes to the outer data-access layer while domain and use-case logic remain untouched."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of entities and value objects treated as a unit for consistency and transactions, which is a conceptual domain concept that does not map 1:1 to a database table."}

{"answer": "yes", "explanation": "Value objects are defined by their attributes/values rather than identity and are typically immutable, so equality is determined by comparing field values."}

{"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the aggregate root is the single external entry point through which all changes to the aggregate must pass to maintain its invariants."}

{"answer": "yes", "explanation": "In DDD, repositories manage aggregate roots, and entities within an aggregate are accessed through their root rather than having their own repositories."}

{"answer": "yes", "explanation": "Ubiquitous language is a core Domain-Driven Design concept where a shared, common vocabulary is developed through collaboration between developers and domain experts, ensuring everyone uses the same terminology to describe the domain model."}

{"answer": "logical completeness", "explanation": "In model theory, logical completeness defines the boundary within which a model and its formal language remain consistent, beyond which the same symbols can be interpreted to yield different, non-isomorphic models."}

{"answer": "no", "explanation": "DDD advocates for a rich domain model where business logic lives inside the objects, whereas an anemic model is widely regarded as an anti-pattern."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a bounded context establishes the boundary within which a specific model applies, so the same concept (like 'Customer') is represented by different classes in different bounded contexts."}

```json ⏎ {"answer": "yes", "explanation": "In the compiled Symfony DI container, services are only instantiated when they are first retrieved via get(), not when the container is built."} ⏎ ```

{"answer": "router:show", "explanation": "The `router:show` command (renamed from `debug:router` in Symfony 6.2+) lists all registered routes in the application."}

{"answer": "no", "explanation": "Symfony's default services.yaml configures autowiring and autoconfiguration for your src/ directory, so services are registered automatically without manual declaration."}

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes and stores them in a cache directory between requests for performance."}

{"answer": "yes", "explanation": "In Symfony's dev environment, the compiled DI container is cached and only rebuilt when tracked resource files (like config and service definitions) change, not on every request."}

```json ⏎ {"answer": "APP_ENV", "explanation": "The APP_ENV environment variable selects the active Symfony environment (e.g., dev or prod), falling back to SYMFY_ENV if not set."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Symfony routing resolves controller actions via reflection and requires them to be public; private (or protected) methods cannot be referenced as actions."} ⏎ ```

{"answer": "no", "explanation": "Event subscribers and event listeners are sorted together by their declared priority value; there is no inherent priority that guarantees subscribers run before listeners."}

{"answer": "no", "explanation": "The new AuthenticatorInterface system became the default in Symfony 5.4/6.0, but the old Guard component was only fully removed in Symfony 6.4, not 6.0."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute verifies a role or permission on a controller method and returns a 403 Forbidden response when the check fails."}

```json ⏎ {"answer": "yes", "explanation": "Voters are Symfony's mechanism for authorizing access to a specific subject (like a $post object) by evaluating a vote based on the attribute and the subject passed to isGranted()."} ⏎ ```

{"answer": "yes", "explanation": "Symfony deprecated and removed annotation support for validation constraints in favor of PHP attributes, which have been the standard since Symfony 4.3 and are the only supported metadata format in Symfony 6.x/7+."}

{"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default via the csrf_protection option (true by default), so the form automatically generates and validates a CSRF token on submission."}

{"answer": "yes", "explanation": "Symfony always performs form validation server-side, so client-side HTML5 checks can be bypassed but never replace the server-side validation."}

{"answer": "make:form", "explanation": "The Symfony MakerBundle's `make:form` command generates a form class (FormType) for you."}

```json ⏎ {"answer": "no", "explanation": "Symfony does not store the password in the session; it stores the authenticated user's identifier in the security token, while passwords are hashed and kept in the user provider/database."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony, bundle and topic configurations are conventionally stored as individual YAML files in config/packages (e.g., framework.yaml, doctrine.yaml, routing.yaml)."}

```json ⏎ {"answer": "yes", "explanation": "The .env file contains committed default/dev configuration, while .env.local is gitignored and holds environment-specific real secrets and overrides."} ⏎ ```

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

{"answer": "no", "explanation": "Once the Symfony container is compiled and frozen (as it is in a running application), calling setParameter() throws a runtime exception, so parameters cannot be changed at runtime from a controller."}

{"answer": "no", "explanation": "In Symfony, services are private (public: false) by default since Symfony 3, and you cannot fetch them directly from the container—this encourages proper dependency injection and improves container performance."}

{"answer": "no", "explanation": "Bundles do not require a config file in config/packages, as many bundles provide working defaults and only need configuration when customization is desired."}

```json ⏎ {"answer": "yes", "explanation": "In Symfony, environment variables are injected into services.yaml using the %env(VAR)% placeholder syntax, allowing services to reference environment values dynamically."} ⏎ ```

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable controls whether Symfony runs in debug mode, which enables the profiler and Twig debugging output."}

{"answer": "no", "explanation": "A single message can be handled by multiple handlers in Symfony Messenger, as you can register several handlers for the same message type through the message-to-handler mapping configuration."}

{"answer": "no", "explanation": "The sync transport processes the message immediately in the same process rather than queueing it for a worker, unlike the async transport which sends messages to a queue for asynchronous worker processing."}

{"answer": "messenger:consume", "explanation": "The Symfony command `messenger:consume` starts the worker (consumer) that processes messages from the Messenger transport/queue."}

```json ⏎ {"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy is configured per transport, allowing each transport to have its own retry settings such as max_retries and retry_multiplier."} ⏎ ```

{"answer": "no", "explanation": "Symfony Messenger's DefaultSerializer uses PHP's native serialize() function by default rather than JSON serialization."}

{"answer": "false", "explanation": "The Symfony Scheduler component runs tasks (closures) directly on a schedule; it does not dispatch messages through the Messenger component."}

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

{"answer": "yes", "explanation": "In Symfony's Messenger component, the bus pipeline is configured as an ordered array of middleware, so you can add custom middleware and position it before or after the built-in ones."}

{"answer": "yes", "explanation": "Symfony's official release schedule indeed follows this pattern: minor versions are released every six months in May and November, while major (LTS) versions arrive every two years in May."}

{"answer": "8.3", "explanation": "Symfony 8.0, following the pattern of requiring newer PHP versions with each major release, mandates a minimum of PHP 8.3 (since Symfony 7.x requires PHP 8.2)."}

{"answer": "false", "explanation": "Symfony 7.0 removed support for docblock annotations (validation, routes), which were deprecated in 6.4; users must now use PHP attributes instead."}

{"answer": "yes", "explanation": "Symfony's AssetMapper manages frontend assets directly through importmap.php without requiring Node.js or webpack."}

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release that receives 5 years of support (2 years of bug fixes plus 3 years of security maintenance)."}

{"answer": "no", "explanation": "In Symfony, each major release removes the deprecations introduced in previous versions, which is a core part of the framework's upgrade and deprecation policy."}

{"answer": "yes", "explanation": "Each Symfony major release includes an UPGRADE.md file documenting the breaking changes and migration steps required for upgrading."}

{"answer": "symfony/importmap", "explanation": "The symfony/importmap component manages frontend assets using browser importmaps, eliminating the need for Node.js or Webpack."}

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

```json ⏎ {"answer": "no", "explanation": "Symfony 8.0 ships in November 2025, so 8.2 follows in May 2026 (not November, which would be 8.4)."} ⏎ ```

{"answer": "8.2", "explanation": "Symfony follows a versioning scheme where minor versions increment by 0.1, so the version after 8.1 is 8.2."}

{"answer": "no", "explanation": "Symfony 8.2 would be a minor release within major version 8, and Symfony guarantees backward compatibility in minor releases, so it would not require rewriting applications—only major releases (like 8.0) introduce breaking changes."}

{"answer": "yes", "explanation": "PHP's versioning policy reserves backward-incompatible changes for major releases, so moving from 8.1 to 8.2 (a minor version) is expected to preserve backward compatibility, adding features and deprecations without breaking existing code."}

{"answer": "8.7", "explanation": "Symfony 8.0 would be released about two years after 7.0, and with a minor release every quarter over that two-year (8-quarter) cycle, 8.7 would be the final minor version before the 9.0 major release."}

{"answer": "no", "explanation": "Symfony 8.0 (Nov 2025) is expected to require PHP 8.3 minimum, not PHP 8.5, and PHP 8.5 isn't even released yet."}

{"answer": "yes", "explanation": "Symfony's deprecation policy guarantees that deprecations introduced in the 8.x branch remain until they are removed in Symfony 9.0, giving developers time to migrate."}

{"answer": "no", "explanation": "Twig's {{ }} is only for outputting expression results using Twig's own templating syntax, not for executing arbitrary PHP code directly."}

```json ⏎ {"answer": "yes", "explanation": "Twig automatically escapes printed variables by default using the HTML escaper unless auto-escape is explicitly disabled."} ⏎ ```

{"answer": "yes", "explanation": "The |e (escape) filter escapes a string to make it safe for HTML output, auto-detecting the appropriate escaping strategy by default."}

{"answer": "localizenumber", "explanation": "The `localizenumber` filter from Twig's intl-extra library formats a number according to a specified locale using the PHP Intl extension."}

{"answer": "yes", "explanation": "The raw filter in Twig marks a value as safe, which disables HTML auto-escaping for that value when it's rendered."}

{"answer": "yes", "explanation": "In Twig, {{ }} is the print/output tag that evaluates and displays an expression, while {% %} is the action tag that executes control logic like if, for, and set."}

{"answer": "false", "explanation": "Twig provides the set tag, allowing you to declare and assign variables directly inside a template, so values are not limited to what comes from the controller."}

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

{"answer": "yes", "explanation": "Bootstrap is a CSS/JavaScript library providing ready-made UI components like buttons, navbars, and modals, and is not an SPA framework like React or Vue."}

{"answer": "container", "explanation": "The .container class applies fixed max-widths that change at each responsive breakpoint in Bootstrap."}

{"answer": "no", "explanation": "Bootstrap's grid uses a 12-column layout (not 16), and modern Bootstrap versions (4 and 5) are built on Flexbox, not CSS floats."}

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

{"answer": "yes", "explanation": "Bootstrap spacing utilities map class suffixes to keys in the $spacers map whose values are multiples of the base $spacer unit (e.g., .mt-3 applies 1*$spacer)."}

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the data-bs-toggle attribute (e.g., data-bs-toggle=\"dropdown\") enables interactive components like dropdowns, modals, and collapse on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 removed the jQuery dependency and was rewritten using vanilla JavaScript for all its components and plugins."}

{"answer": "yes", "explanation": "In Bootstrap 5.3+, dark mode is enabled by adding the .dark class to the root (html) element, which activates dark color mode variables."}

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

{"answer": "persist", "explanation": "EntityManager::persist() marks a new object as managed and defers the SQL INSERT until flush() is invoked."}

{"answer": "false", "explanation": "Doctrine ORM 3.0 removed EntityManager::merge() entirely, which had been deprecated since 2.x, so the method no longer exists in version 3."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is written in terms of PHP entities and their mapped fields rather than database tables and columns, making it database-agnostic."}

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

{"answer": "no", "explanation": "Doctrine does not auto-flush by default; you must call $em->flush() (or persist+flush) explicitly to save changes to the database."}

```json ⏎ {"answer": "yes", "explanation": "For a managed entity, Doctrine's Unit of Work performs automatic dirty checking, so modifying a property and calling flush() will persist the change without an explicit persist() call."} ⏎ ```

{"answer": "no", "explanation": "In Doctrine ORM, remove() only marks the entity for deletion, and the actual SQL DELETE is executed when flush() is called."}

{"answer": "false", "explanation": "PostgreSQL's MVCC is specifically designed so that readers do not block writers and writers do not block readers, which is the primary advantage of MVCC over traditional locking mechanisms."}

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

{"answer": "no", "explanation": "SERIAL is a legacy mechanism that implicitly creates a sequence and sets a default via nextval(), while GENERATED ... AS IDENTITY is the SQL-standard identity column feature that provides finer control over the underlying sequence."}

{"answer": "false", "explanation": "In PostgreSQL, NULL values are treated as distinct, so a UNIQUE constraint allows multiple rows with NULL in the column."}

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

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

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

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

```json ⏎ {"answer": "yes", "explanation": "By default PostgreSQL operates in autocommit mode, so each SQL statement is automatically wrapped in its own transaction that is committed immediately unless an explicit transaction block (BEGIN...COMMIT) is used."} ⏎ ```

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

```json ⏎ {"answer": "yes", "explanation": "Indexes speed up not only SELECT but also UPDATE and DELETE operations that search on an indexed column, because the database can quickly locate the matching rows using the index instead of scanning the entire table."} ⏎ ```

{"answer": "yes", "explanation": "SAVEPOINT allows you to roll back to a specific point within a transaction without discarding the entire transaction."}

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

{"answer": "pgvector", "explanation": "pgvector is the PostgreSQL extension that adds vector data types (like vector) and indexes (like IVF, HNSW, and PGann) for similarity search on embeddings."}

{"answer": "yes", "explanation": "A partial index only contains index entries for rows that satisfy the WHERE predicate, so it is built only over that subset of rows."}

{ ⏎   "answer": "no", ⏎   "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which records read/write ranges and aborts transactions upon detecting serialization failures at commit time, rather than simply locking the rows as they are read (the two-phase locking approach used by databases like Oracle or SQL Server)." ⏎ }

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

{"answer": "204", "explanation": "HTTP 204 No Content indicates the request succeeded but there is no response body to send, commonly used after DELETE operations."}

{"answer": "yes", "explanation": "DELETE is defined as an idempotent HTTP method, so sending multiple DELETE requests to the same resource results in the same state, with subsequent requests returning a 404 once the resource no longer exists."}

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

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

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

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that the PATCH method is not required to be idempotent, in contrast to PUT which must be idempotent."}

{"answer": "no", "explanation": "Using == can trigger PHP type-juggling issues (e.g., numeric strings compared as floats) and is not constant-time against timing attacks, so hash_equals() should be used instead."}

{"answer": "yes", "explanation": "CSRF tokens are generated server-side, bound to the session, and validated on the server for state-changing (unsafe) requests like POST, preventing cross-site request forgery."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to configure and enable a Content Security Policy that controls which resources a browser is allowed to load."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework that grants delegated access, not an authentication protocol; the access token indicates what a client is authorized to do, not who the user is (that role belongs to OpenID Connect's ID token)."}

{"answer": "no", "explanation": "XSS is primarily prevented by encoding/escaping output when rendering data to the browser, not by validating input before storing it in a database, since data could still be rendered unsafely later from any source."}

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

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

```json ⏎ {"answer": "no", "explanation": "Salts are not secret; they are stored alongside the hash and used during verification to recompute the same hash, so their secrecy is unnecessary and the statement is false."} ⏎ ```

{"answer": "no", "explanation": "PHPUnit only recognizes and runs test methods in classes that extend PHPUnit\Framework TestCase; the extension is required for test discovery."}

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

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

{"answer": "expectException()", "explanation": "The expectException() method declares an expectation that an exception of the specified class will be thrown during a test, replacing the deprecated setExpectedException() method."}

{"answer": "false", "explanation": "The roles are reversed: a stub returns predefined data without verifying calls, while a mock verifies which methods were called on it."}

{"answer": "yes", "explanation": "In PHPUnit 10, the @dataProvider annotation was deprecated in favor of the #[DataProvider] PHP attribute, which is the recommended approach."}

{"answer": "no", "explanation": "PHPUnit does allow test dependencies through the @depends annotation, so a test can depend on the result of another test."}

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

```json ⏎ {"answer": "3-3", "explanation": "intdiv(7,2) truncates toward zero to 3, and intdiv(-7,2) truncates toward zero to -3, so the concatenated result is \"3-3\"."} ⏎ ```

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

```json ⏎ {"answer": "true", "explanation": "Both `'1e1'` and `'10'` are numeric strings (scientific notation), so PHP performs a numeric comparison where 1e1 equals 10, making the comparison true."} ⏎ ```

{"answer": "zero", "explanation": "PHP's switch uses loose comparison, so the string 'a' is converted to the integer 0, matching case 0 and echoing 'zero'}

{"answer": "2c", "explanation": "When strtr receives an associative array, it replaces the longest matching substring first, so 'ab' is matched and replaced with '2' before 'a', yielding '2c'."}

{"answer": "[hello]", "explanation": "The offset -10 is before the start of the 5-character string, so substr returns the entire string 'hello', giving the output [hello]."}

{"answer": "k,n,m", "explanation": "The + union operator keeps the left array's values for matching keys (so 'k'=>1 from $a wins) and appends $b's keys not already present ('m'), giving keys k, n, m in that order."}

{"answer": "yxz", "explanation": "Sorting by the third column ascending places [2,'y',1] first (value 1), then the two value-2 items retain their original relative order due to usort's stability in PHP 8.0, so array_column extracts 'y', 'x', 'z'."}

```json ⏎ {"answer": "4", "explanation": "Named argument unpacking matches array keys 'a' and 'b' to the parameters, so $a=5 and $b=1, giving 5-1=4."} ⏎ ```

```answer ⏎ {"answer": "3", "explanation": "The `$p->g(...)` first-class callable syntax binds the object handle to the resulting closure, so even after `$p = null` the object still exists (its reference count stays above zero), and calling `$f()` returns the private property value 3."} ⏎ ```

```json ⏎ {"answer": "B", "explanation": "Due to late static binding, static::class returns the runtime class B rather than the declared class A."} ⏎ ```

{"answer": "10", "explanation": "The set hook stores $value doubled, so `$c->x = 5` writes 10 into the backing field, and the default get hook returns that stored value of 10."}

{"answer": "BA", "explanation": "The conflict is resolved by making TB::f the primary f (returning 'B'), while TA::f is aliased to g (returning 'A'), so the concatenation yields 'B'.'A' = 'BA'."}

{"answer": "0", "explanation": "When a trait is used by multiple classes, each class receives its own independent copy of the trait's static properties, so setting CX::$n to 1 does not affect CY::$n which remains 0."}

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

{"answer": "second", "explanation": "The inner try's RuntimeException is discarded because the finally block throws a LogicException that supersedes it, and the outer catch catches that LogicException and echoes its message 'second'."}

{"answer": "App\\Foo|Baz", "explanation": "In namespace N, the use statement aliases Baz to App\\Foo, so Baz::class resolves to App\\Foo, while the leading backslash in \\Baz forces global-namespace resolution, giving Baz."}

{"answer": "yesyes", "explanation": "Both class_exists calls resolve to Ns\\Foo (the first via namespace-relative resolution, the second via explicit concatenation), which exists, so both yield 'yes'."}

{"answer": "1,2,99", "explanation": "The foreach loop leaves $v as a reference to the last array element, so $v = 99 modifies $a[2], making the array [1,2,99]."}

{"answer": "3", "explanation": "The static $n variable lives in the method's execution context defined in class A, so it is shared across instances of A and its subclass B, incrementing through 1, 2, then echoing 3."}

```json ⏎ {"answer": "11", "explanation": "send(10) resumes the generator, making the yield expression evaluate to 10 so $x=10, and the function returns $x+1=11 which getReturn() retrieves."} ⏎ ```

```json ⏎ {"answer": "1,2,ok", "explanation": "yield from delegates the inner generator (yielding 1 and 2) and assigns its return value 'ok' to $r, which is then yielded, producing the array [1, 2, 'ok']."} ⏎ ```

{"answer": "noyes", "explanation": "The first call checks cost 4 against a hash with cost 4 (match, so no rehash needed → 'no'), while the second checks cost 5 against cost 4 (mismatch, so rehash needed → 'yes')."}

{"answer": "strict-in", "explanation": "E_ALL = 32767 still includes the E_STRICT bit (2048), and since the code uses the literal 2048 rather than the deprecated E_STRICT constant, no deprecation fires, so (32767 & 2048) = 2048 which is non-zero, making the ternary evaluate to 'strict-in'."}

{"answer": "mapped", "explanation": "Symfony's Request::create maps the server variable HTTP_X_TOKEN to the header X-Token (stripping the HTTP_ prefix and converting underscores to hyphens), so get('X-Token') returns 'abc'."}

```json ⏎ {"answer": "BCA", "explanation": "Symfony's EventDispatcher executes listeners with higher priority first, so B (priority 10), then C (priority 5), then A (priority 0)."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "Doctrine ORM maintains a first-level identity map per EntityManager, so both finds for the same primary key return the exact same managed instance, yielding identical spl_object_id values."} ⏎ ```

{"answer": "0", "explanation": "persist() schedules the new entity for insertion in the Unit of Work, but remove() (with no ID yet) simply unsets it from the insert queue, so flush() issues no SQL and the table stays empty."}

```json ⏎ {"answer": "1", "explanation": "count(x) counts only non-NULL values, so it counts just the value 1 and ignores the NULL."} ⏎ ```

```json ⏎ {"answer": "10,30,60", "explanation": "The inner query computes a running sum of x ordered by id (10, 30, 60), and string_agg concatenates those values as text in id order separated by commas."} ⏎ ```

{"answer": "M1M2", "explanation": "M1 is the outermost middleware (registered first), so it echoes 'M1' then delegates to M2 which echoes 'M2' before the final handler runs."}

{ ⏎  "answer": "1", ⏎  "explanation": "HandlersLocator::getHandler() returns only the first matching handler descriptor (the one for alias 'h1'), so only the first handler runs and increments $n by 1, never reaching the +10 handler." ⏎ }

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

{"answer": "2", "explanation": "The unique constraint is DEFERRABLE INITIALLY DEFERRED, so the duplicate-check is postponed until COMMIT (which never happens), meaning both rows remain visible when SELECT count(*) executes."}

```json ⏎ {"answer": "6", "explanation": "The filter regex 'test_sum' is not anchored, so it matches both test_sum and test_sum_abs, each running 3 data-provider cases (1, 2, 3), totaling 6 tests."} ⏎ ```

{"answer": "2, 1", "explanation": "The data provider supplies two cases (1 and -1), so 2 tests run; the assertion assertTrue($x > 0) passes for 1 but fails for -1, so exactly 1 test fails."}

{"answer": "POST", "explanation": "The -d/--data option in curl sends an HTTP POST request and sets the Content-Type to application/x-www-form-urlencoded."}

{"answer": "GET", "explanation": "The `-G` flag tells curl to send the `-d` data as a query string using the HTTP GET method instead of the default POST."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 §5.2, invalid_client must be used when the request is not associated with an existing client, so a non-existent client_id yields this error."}

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

{"answer": "6", "explanation": "The `default` filter returns 2 because `false` is considered an empty value, and then 2 * 3 equals 6."}

{"answer": "no exception is thrown (renders 'a12')", "explanation": "In Twig, ~ and + are left-associative at the same precedence level, so the expression evaluates as ('a' ~ 1) + 2, and Twig_add converts 'a1' + 2 by concatenation to 'a12' rather than throwing an exception."}

{"answer": "0", "explanation": "The array [''] is validated as a whole by NotBlank, and since it is a non-empty array (not 'blank'), no violation is generated, so count() returns 0."}

```json ⏎ {"answer": "Symfony\\Component\\Form\\Exception\\UnexpectedException", "explanation": "Calling isValid() on a form that has never been submitted throws an UnexpectedException because the form is uninitialized."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "Since the service 'a' is public, the container instantiates it once and caches the instance in $this->services, so both get() calls return the same object."} ⏎ ```

{"answer": "hi Bob!", "explanation": "The container resolves recursive parameter placeholders during compile(), so 'message' '%greeting'!' becomes 'hi Bob' via 'greeting' 'hi %name%!' becoming 'hi Bob' via 'name' 'Bob'."}

{"answer": "960px", "explanation": "In Bootstrap 5.3, the .container uses min-width media queries, so at 992px the 'lg' breakpoint (≥992px) applies, giving a max-width of 960px."}

```json ⏎ {"answer": "text-primary", "explanation": "In Bootstrap's compiled CSS, text-primary is generated after text-danger, so the cascade gives text-primary precedence."} ⏎ ```

```json ⏎ {"answer": "2", "explanation": "OrderService is in the Domain layer, which may only depend on Domain, so its two forbidden dependencies (App\\Application\\PlaceOrder and App\\Infrastructure\\Db) each count as one violation."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "BillingService is in the Domain layer, which can only depend on Domain, so each of its three forbidden cross-layer dependencies (Application\\PlaceOrder, Infrastructure\\Db, Infrastructure\\Logger) counts as one deptrac violation."} ⏎ ```

{"answer": "10,15", "explanation": "$a has amount 10, and $c is the result of adding Money(5) to Money(10), giving amount 15, so it echoes 10,15."}

{"answer": "1", "explanation": "add('a') stores one item, then remove('a') sees count === 1 and throws DomainException before the unset runs, so the array still holds 'a' and count() returns 1."}

```json ⏎ {"answer": "hi", "explanation": "The code creates a new instance of class C and immediately calls its hi() method which returns 'hi', which is then echoed."} ⏎ ```

{"answer": "yesno", "explanation": "`newLazyGhost` creates an uninitialized lazy object, so the first check prints 'yes'; accessing `$o->v` triggers the initialization closure (setting `v=21`) and marks the object initialized, so the second check prints 'no'."}

{"answer": "no", "explanation": "The Symfony Guard authentication system (including AbstractGuardAuthenticator) was deprecated in 5.2 and removed in Symfony 7.0, so it does not exist in 8.1."}

{"answer": "noyes", "explanation": "In Symfony 8.1, the deprecated `AnnotationClassLoader` was removed (deleted in 7.0), so the first check yields 'no', while `AttributeClassLoader` still exists as the current attribute-based loader, yielding 'yes'."}