Карта знаний PHP — bonsai-2:27b, run-26 · think: medium

{"answer": "no", "explanation": "Double-quoted strings support variable interpolation and most escape sequences, while single-quoted strings treat variables as literal text and only recognize \\ and \\' as escape sequences."}

{"answer": "yes", "explanation": "The null coalescing operator ?? treats undefined variables and null values identically (both yield the right operand) and explicitly does not emit undefined-variable warnings, following isset-like semantics."}

{"answer": "ab", "explanation": "PHP's echo statement concatenates multiple expressions separated by commas without adding any separators, so it prints 'ab'."}

{"answer":"no","explanation":"While print does return the value 1, it is a language construct in PHP and cannot be used inside an expression (e.g., you cannot write echo print(\"hello\") or if (print(\"x\") == 1))."}

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

{"answer": "yes", "explanation": "In PHP's operator precedence table, the concatenation operator (.) is listed below the additive operators (+ and -), meaning it binds more loosely and is evaluated after addition and subtraction."}

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

{"answer":"sum: 5","explanation":"The + operator has higher precedence than the . (concatenation) operator, so it is evaluated as 'sum: ' . (2 + 3), producing the string 'sum: 5'."}

{"answer":"no","explanation":"With ===, arrays must have the same keys in the same order with identical values; order is not ignored."}

{"answer": "no", "explanation": "In PHP, `0 == false` actually returns `true` (since `false` is cast to `0`), and `==` is a loose comparison operator, not a strict one (`===` is strict)."}

{"answer": "yes", "explanation": "In PHP 8, a non-numeric string like \"abc\" is converted to 0 when compared with a number using ==, so 0 == 0 evaluates to true."}

{"answer": "yes", "explanation": "In PHP's loose comparison (==), null is considered equal to 0, \"\", and false, all of which return true."}

{"answer": 42, "explanation": "Casting the string '42abc' to an integer in PHP extracts the leading numeric portion, which is 42."}

{"answer": 10, "explanation": "In PHP, the + operator coerces both operands to numbers, so '5' becomes 5 and 5 + 5 equals 10."}

{"answer": "no", "explanation": "In PHP, casting false to a string results in an empty string (\"\"), not \"0\"."}

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

{"answer": "no", "explanation": "strrev() reverses bytes, not characters, so multi-byte UTF-8 characters will be corrupted; mb_strrev() is the correct function for UTF-8 strings."}

{"answer": "yes", "explanation": "The string 'world' is a substring of 'Hello world', so str_contains() returns true."}

{"answer": "no", "explanation": "str_pad() can pad on the right, left, or both sides via its padding parameter (STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH)."}

{"answer": "no", "explanation": "By default, trim() strips all whitespace characters including spaces, tabs, newlines, carriage returns, vertical tabs, and form feeds."}

{"answer": 6, "explanation": "In UTF-8, the character 'é' is encoded as 2 bytes, so 'héllo' contains 5 characters but 6 bytes total (1+2+1+1+1)."}

{"answer": "def", "explanation": "When the start parameter is negative, it counts from the end of the string, so -3 means starting at the third-to-last character, returning 'def'.}"}

{"answer": "no", "explanation": "In PHP, ucfirst() returns a new string with the first character uppercased; it does not modify the original string in place because strings are passed by value."}

{"answer": "yes", "explanation": "Heredoc uses double-quote-style rules allowing $variable interpolation, while nowdoc uses single-quote-style rules treating the content as a literal string with no variable interpolation."}

{"answer":"no","explanation":"The sort() function re-indexes the array with sequential integer keys, so it does not preserve key-to-value associations; use asort() or ksort() instead."}

{"answer": "yes", "explanation": "In PHP, numeric string keys in arrays are automatically cast to integers, so '5' is stored as the integer key 5."}

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

{"answer": "yes", "explanation": "When no callback is provided, array_filter() removes all falsy elements (0, 0, \"\", null, false) from the array."}

{"answer": "no", "explanation": "By default, array_slice() reindexes the keys (the second parameter preserve_keys defaults to false), so original numeric keys are NOT preserved."}

{"answer": "[20, 30]", "explanation": "array_slice starts at index 1 and returns 2 elements from the array [10, 20, 30, 40]."}

{"answer": 2, "explanation": "The + operator merges arrays with left-side values taking priority on key collisions, resulting in ['a' => 1, 'b' => 2]."}

{"answer": "yes", "explanation": "Prior to PHP 8.1, the spread operator in array context could only be used with list arrays (integer-keyed); PHP 8.1 lifted this restriction, allowing it to work with arrays that have string keys."}

{"answer":"yes","explanation":"PHP explicitly prohibits mixing named arguments and the unpacking operator (...$args) within the same function call, treating it as a syntax error."}

{"answer":"no","explanation":"In PHP, a closure (anonymous function) does not automatically inherit variables from the enclosing scope; you must explicitly capture them with the use keyword."}

{"answer": 3, "explanation": "func_num_args() returns the actual number of arguments passed to the function call, which is 3 in this case, regardless of the declared parameter list."}

{"answer": "no", "explanation": "PHP arrow functions (fn) can only contain a single expression after the => operator and do not support a curly-brace body with multiple statements; that syntax belongs to regular closures (function)."}

{"answer": "yes", "explanation": "In PHP 8.0+, arrow functions (fn) capture enclosing variables by reference, meaning they read the variable's current value at call time rather than snapshotting it at definition time."}

{"answer":"yes","explanation":"In PHP, a `static function () {}` closure explicitly disables binding to the current object context, so `$this` is not automatically captured inside it."}

{"answer": 5, "explanation": "The closure captures $x by value (no & prefix), so it retains the value 5 from when it was defined, regardless of the later reassignment to 7."}

{"answer": "yes", "explanation": "In PHP's weak typing mode (the default, without `declare(strict_types=1)`), the string \"5\" is automatically coerced to the integer 5 when passed to an int-typed parameter, so it is allowed."}

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, allowing visibility modifiers and type declarations to be added directly to constructor parameters, which automatically creates and assigns the corresponding property."}

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

{"answer": "yes", "explanation": "In PHP, the `final` keyword prevents a method from being overridden in a subclass, so this statement is true."}

{"answer": "no", "explanation": "In PHP, private properties of a parent class are only accessible within the class where they are declared and are not accessible in subclasses."}

```json ⏎ {"answer": "AnonymousClass", "explanation": "In PHP, get_class() on an instance of an anonymous class (new class {}) returns a string like \"AnonymousClass\\0/file.php:42\" where the NUL byte separates the class-type identifier from the file/line info, so the part before the NUL byte is \"AnonymousClass\"."} ⏎ ```

{"answer": "yes", "explanation": "Private methods are not inherited in PHP, so the child class's method of the same name is completely independent and can have any visibility without conflict."}

{"answer": "yes", "explanation": "In PHP, the __get() magic method is invoked when you attempt to read a property that is not defined on the object, i.e., a non-existent property."}

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP 8.1+ throws a ReadonlyPropertyAccessError, which extends Error (not Exception)."}

{"answer": "yes", "explanation": "In PHP, interfaces can declare constants, which are implicitly public and cannot be assigned initial values."}

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

{"answer": "no", "explanation": "In PHP, interfaces can only declare abstract instance methods and public constants; they cannot declare static methods."}

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

{"answer": "no", "explanation": "In PHP, interface methods only declare signatures (abstract methods) and cannot contain any implementation code, unlike trait methods which can provide concrete implementations."}

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared as either public (the default) or protected, so a protected abstract method is perfectly valid."}

{"answer": 3, "explanation": "The static method Foo::cases() returns an array of all enum cases, and this enum has 3 cases (A, B, C)."}

{"answer": "yes", "explanation": "In PHP, a trait can declare constants using the 'const' keyword."}

{"answer":"yes","explanation":"In PHP's exception hierarchy, Throwable is the abstract base class from which both Exception and Error extend."}

{ ⏎   "answer": "no", ⏎   "explanation": "TypeError inherits from Error, not from Exception; both are siblings under Throwable, so catch (Exception $e) will not catch TypeError." ⏎ }

{"answer":"no","explanation":"The @ operator suppresses notices, warnings, and errors, but it does not suppress exceptions; exceptions must be handled with try/catch blocks."}

{"answer": "DivisionByZeroError", "explanation": "In PHP, intdiv() throws a DivisionByZeroError when the divisor is zero."}

{"answer": "no", "explanation": "The finally block always executes when the try block completes, regardless of whether an exception was thrown, caught, or not thrown at all."}

{"answer": "yes", "explanation": "The finally block executes after the try block has already completed or thrown, so any exception thrown inside finally cannot alter the try block's result; it only affects what propagates outward."}

{"answer": "yes", "explanation": "Casting any instantiated object to bool in PHP returns true, since a non-NULL object is considered truthy."}

{"answer": "yes", "explanation": "Functions registered via register_shutdown_function() are executed during PHP's shutdown phase, which includes when exit() or die() is called."}

{"answer": "no", "explanation": "The `use` statement is a compile-time alias that only shortens the class name; it does not trigger the autoloader or load the class file — the file is loaded only when the class is actually instantiated or otherwise invoked at runtime."}

{"answer": "function", "explanation": "In PHP namespaces, you use `use function Vendor\\Package\\name;` to import a function, while `use const` is for constants and `use class` is for classes."}

{ ⏎   "answer": "src/Controller/Api/UserController.php", ⏎   "explanation": "PSR-4 maps each namespace segment to a directory, so App\Controller\Api becomes src/Controller/Api with the class file name UserController.php." ⏎ }

{"answer":"yes","explanation":"Composer's vendor/autoload.php calls spl_autoload_register() to register its custom classmap and prefix-based autoloaders."}

{"answer": "yes", "explanation": "In PHP, __NAMESPACE__ is a magic constant that returns the name of the namespace in which it is defined, or an empty string if in the global namespace."}

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

{"answer": "yes", "explanation": "With PSR-4 mapping App\\ to src/, the class App\\Model\\User is placed at src/Model/User.php, which is the correct filesystem path."}

{"answer": "yes", "explanation": "In PHP, a `use` statement placed inside a function body is valid and creates a scoped import that is only available within that function."}

{"answer": "yes", "explanation": "In PHP, assigning an array to another variable creates a copy (using a copy-on-write optimization), not a reference; you must use the & operator to pass by reference."}

{"answer": 2, "explanation": "PHP copies arrays by default, so modifying $b does not affect $a."}

{"answer": "yes", "explanation": "In PHP, variables declared in the global scope are not directly visible inside functions; you must use the 'global' keyword, the $GLOBALS superglobal, or pass them as parameters to access them."}

{"answer": "no", "explanation": "$GLOBALS is a reference to the global scope, so unset($GLOBALS['x']) removes the variable from the global scope permanently, not just within the current function."}

{"answer": 6, "explanation": "The parameter is passed by reference, so $x++ increments the original variable $n from 5 to 6."}

{"answer":"no","explanation":"A foreach by value iterates over a snapshot (copy) of the array, so modifications to the original array during the loop are not visible in the ongoing iteration."}

{"answer": "no", "explanation": "Static properties belong to the class itself, not to individual instances, so they are shared across all instances and changes are visible in every one."}

{"answer":"no","explanation":"In PHP, array keys are automatically cast to integers or strings; the boolean true is cast to the integer 1, not stored as a boolean."}

{"answer": "yes", "explanation": "Since PHP 7, a `return` with a value is allowed inside a generator, and the returned value can be retrieved via $gen->getReturn()."}

{"answer": "no", "explanation": "In PHP, once a generator has been fully consumed, it is in a finished state and cannot be rewound; the rewind() method only works when the generator is in its initial (not-yet-started) state."}

{"answer":"yes","explanation":"yield from delegates to another generator or iterable by yielding its values as if they were produced by the enclosing generator."}

{"answer":"Generator","explanation":"Calling a generator function with yield returns a Generator object, and get_class() on it returns the string \"Generator\"."}

{"answer": 3, "explanation": "The generator yields three values (1, 2, 3), iterator_to_array converts them into an array of 3 elements, and count returns 3."}

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

{"answer": "yes", "explanation": "ArrayIterator is a built-in PHP class that wraps an array and implements the Iterator interface, allowing it to be traversed with foreach, next(), current(), key(), valid(), and rewind()."}

{"answer": "no", "explanation": "ArrayObject implements the Traversable interface, so it can be traversed with foreach."}

{"answer": "yes", "explanation": "password_hash() automatically generates and embeds a salt in the returned hash string; it does not accept a salt as a parameter."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT in PHP 8 defaults to bcrypt, not MD5; MD5 is a fast hash function not intended for password storage."}

{"answer":"yes","explanation":"password_verify compares the given password 'secret' against the hash generated from 'secret', so it returns true."}

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags to mitigate XSS attacks, but SQL injection is prevented using prepared statements or parameterized queries, not by stripping tags."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID while preserving session data, invalidating any previously known (attacker-set) session ID and thus protecting against session fixation attacks, typically called upon login."}

{"answer": "php_sapi_name()", "explanation": "The php_sapi_name() function returns the name of the PHP SAPI (Server API) module, such as 'cli', 'apache2handler', or 'fpm-fcgi'."}

{"answer":"yes","explanation":"session_destroy() only removes the session data from server-side storage; to also delete the session cookie from the browser you must explicitly set a cookie with an expired timestamp (e.g., setcookie with a past expiry)."}

{"answer": "no", "explanation": "The $_SESSION superglobal is only available after session_start() has been called; without it, session data is not populated or accessible."}

{"answer": "no", "explanation": "The array_find() function does not exist in PHP and was never introduced in any version; PHP offers array_search() and array_filter() instead."}

{"answer": "yes", "explanation": "PHP 8.4 introduced property hooks, allowing `get` and `set` subroutines to be declared directly within the property declaration in the class body."}

{"answer": "no", "explanation": "PHP 8.4 did not introduce 'asymmetric visibility' with a private(set) modifier; no such syntax exists in PHP."}

{"answer": 8.3, "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.3, allowing developers to mark function return types to require that the return value be used."}

{"answer": "Not applicable", "explanation": "PHP has never introduced a pipe operator (|>), so there is no version in which it first appeared."}

{"answer": "no", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) was never implemented in any PHP version; PHP's clone operator only supports clone $obj without additional arguments."}

{"answer": "no", "explanation": "array_first() and array_last() are not standard PHP functions and were never introduced in any PHP version."}

{"answer": "I do not have reliable information about a PHP RFC called 'Partial Function Application v2' or the specific version it was adopted for. This appears to be an RFC beyond my knowledge, or possibly does not exist.", "explanation": "I am not aware of a PHP RFC titled 'Partial Function Application v2' in my training data, so I cannot confidently provide a version number for it."}

{"answer": "8.1", "explanation": "The clamp() function was introduced via RFC in PHP 8.1."}

{"answer": "no", "explanation": "There is no recognized PHP RFC known as 'Context Managers v2' that was adopted; the context manager modernization (the `use` statement for context managers) was part of PHP 8.3, but a separate 'v2' RFC is not a documented PHP feature."}

{"answer": "yes", "explanation": "PHP has not adopted generics, and RFC proposals for bound-erased generic types have been declined by the core team."}

{"answer": "no", "explanation": "As of my knowledge, no RFC to make ZTS (Zend Thread Safety) the default build option in PHP had been accepted; ZTS remained an optional build configuration."}

{"answer": "yes", "explanation": "PHP 8.5 does not include native generics or parameterized types; the language still lacks a built-in generic mechanism despite years of discussion."}

{"answer": "yes", "explanation": "This aligns with PHP's established annual release cycle, where PHP 8.5 (released November 2025) would be the latest stable version until PHP 8.6 reaches GA in November 2026."}

{"answer": "yes", "explanation": "PHP 6 was never released; development continued from 5.6 directly into 7.0."}

{"answer": "yes", "explanation": "The RFC for the #[\\Deprecated] attribute was adopted for PHP 8.4."}

{"answer": "yes", "explanation": "In both Clean and Onion architectures, dependencies point inward toward the core, meaning inner (core) layers are unaware of and independent from outer (interface, infrastructure) layers."}

{"answer": "yes", "explanation": "A core DDD/Clean Architecture principle: domain entities must be pure PHP with no framework or ORM dependencies, so they remain portable and testable independent of Doctrine or Symfony."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation layer, not the business-logic layer; calling use cases (which reside in the business-logic layer) is a dependency pointing inward, but it does not reclassify the callers themselves as business logic."}

{"answer": "Domain", "explanation": "In onion architecture, the domain (core business rules) sits at the very center, with all other layers depending inward on it."}

{"answer":"yes","explanation":"Static layer-dependency analyzers like deptrac scan the codebase for forbidden cross-layer calls and automatically fail the build when such violations are detected."}

{"answer": "no", "explanation": "Passing an HTTP Request or EntityManager directly into a use case couples business logic to transport and persistence concerns; the interactor should instead receive domain objects or value objects, keeping it framework-independent and easier to test."}

{"answer": "Repository", "explanation": "A Repository is an abstraction that provides a collection-like interface to access domain entities/aggregates while encapsulating and hiding the underlying storage mechanism."}

{"answer": "yes", "explanation": "In clean architecture, the domain and use cases depend on abstractions (e.g., a Repository interface), so changing the concrete database only requires modifying the outer infrastructure layer's repository implementation."}

{"answer": "no", "explanation": "An aggregate is a domain-level consistency boundary that groups related entities, not a direct synonym for a database table."}

{"answer": "yes", "explanation": "A Value Object is indeed immutable and implements value-based equality, meaning two instances are considered equal if their fields hold the same values, regardless of their identity or reference."}

{"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the Aggregate Root is the single external entry point of an aggregate, ensuring all changes to the aggregate's entities go through it to maintain consistency."}

{"answer": "yes", "explanation": "In DDD, a repository is tied to an aggregate root because it manages the entire aggregate's consistency, and individual entities are accessed through the aggregate root rather than having their own repositories."}

{"answer": "yes", "explanation": "In Domain-Driven Design, Ubiquitous Language is the common language shared by developers, domain experts, and other stakeholders to describe the domain, making the statement true."}

{"answer":"domain","explanation":"In model theory the domain (or universe of discourse) fixes the interpretation of a language, making the model internally consistent, while outside that domain the same symbols can be interpreted by different models."}

{"answer": "no", "explanation": "DDD advocates for rich domain models where business logic is encapsulated within domain objects, not pushed into service classes in an anemic model."}

{"answer": "yes", "explanation": "In DDD, each bounded context maintains its own model, so the same concept (e.g., 'Order') can be modeled with different classes and behaviors in different contexts."}

{"answer": "yes", "explanation": "By default, Symfony DI container services are instantiated lazily on first request, unless explicitly marked as eager."}

{"answer": "routes", "explanation": "The `routes` command (e.g., `symfony routes` or `php bin/console routes`) lists all registered routes in a Symfony application."}

{"answer": "no", "explanation": "Symfony autowiring automatically discovers and registers services based on naming conventions and namespaces, so you do not need to manually declare every service in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes (extending Twig\\Template) and stores them as cached .php files on disk, so they are not recompiled on every request."}

{"answer": "yes", "explanation": "In Symfony's dev environment, the compiled DI container is cached and reused across requests; it is only recompiled when one of the tracked files it depends on has changed."}

{"answer": "APP_ENV", "explanation": "Symfony uses the APP_ENV environment variable to select the active environment (e.g., APP_ENV=dev or APP_ENV=prod)."}

{"answer": "no", "explanation": "Symfony routing requires controller methods to be public; the action handler will throw an exception if it encounters a non-public (private or protected) method."}

{"answer": "no", "explanation": "There is no built-in PHP or universal framework rule that subscribers always take priority over listeners; event dispatch order is typically determined by explicit priority values, not by which interface is implemented."}

{"answer":"yes","explanation":"In Symfony 6.0 the legacy Guard system (e.g. custom GuardAuthenticator classes, addAuthenticator on the Guard chain) was fully removed, and all custom authentication now builds on classes implementing Symfony\\Component\\Security\\Authentication\\AuthenticatorInterface (introduced in 5.3)."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute checks whether the authenticated user has a specific role or permission, and returns a 403 Forbidden if they do not."}

{"answer": "yes", "explanation": "In Symfony, Voters are used to perform object-level (attribute-level) authorization checks like isGranted('EDIT', $post)."}

{"answer": "yes", "explanation": "In Symfony 7+, validation uses PHP attributes (e.g., #[Assert\\NotBlank]), and since Symfony 7 requires Doctrine ORM 6+ which removed annotation support, Doctrine ORM annotations are no longer supported."}

{"answer":"yes","explanation":"Symfony automatically generates and validates a CSRF token on form submission by default."}

{"answer":"yes","explanation":"Symfony always performs server-side form validation using its Validation component, regardless of whether HTML5 client-side checks passed, because client-side validation is never a substitute for server-side security."}

{"answer": "make:form", "explanation": "The 'make:form' Symfony maker command generates a FormType class for use in Symfony's form system."}

{"answer": "no", "explanation": "Symfony does not store the user's password in plain text in the session; it only stores an authentication token/identity after successful login, and passwords are hashed in the database."}

{"answer": "yes", "explanation": "In Symfony 4+, bundle and component configurations are placed in config/packages as separate YAML files, one per bundle or topic (e.g., config/packages/security.yaml)."}

{"answer": "yes", "explanation": "This is a widely adopted best practice: `.env` holds non-sensitive development defaults committed to the repo, while `.env.local` holds real secrets and is excluded via .gitignore."}

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

{"answer": "false", "explanation": "Once the Symfony container is frozen (as it is in production and after compilation), calling setParameter() from a controller throws a RuntimeException, making it impossible to modify parameters at runtime."}

{"answer": "yes", "explanation": "In Symfony, the public attribute of a service defaults to true, allowing direct retrieval from the service container."}

{"answer":"no","explanation":"Configuration is not mandatory for every bundle; a bundle can work with its default configuration or even without any dedicated config file in config/packages."}

{"answer":"yes","explanation":"In Symfony, environment variables can be injected into YAML configuration files like services.yaml using the %env(VAR_NAME)% syntax."}

{"answer": "DEBUG", "explanation": "The DEBUG environment variable controls Symfony's debug mode, enabling the web profiler and Twig's debug feature when set to true/1."}

{"answer": "no", "explanation": "A single Symfony Messenger message can be handled by multiple handlers (subscribers) registered for the same message type or channel."}

{"answer": "no", "explanation": "The sync transport does not queue the message for a worker; it handles the message immediately within the same request without persisting it in a queue."}

{"answer": "bin/console messenger:consume", "explanation": "In Symfony, the messenger:consume command starts a worker that listens to and processes messages from the configured transport."}

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

{"answer": "yes", "explanation": "By default, Symfony Messenger serializes messages to JSON using the JsonTransportMessageSerializer when a transport requires serialization."}

{"answer":"yes","explanation":"The Symfony Scheduler component creates messages according to a defined schedule and uses the Messenger component to dispatch them."}

{"answer": "doctrine", "explanation": "The Doctrine transport in Symfony Messenger persists messages as rows in database tables managed via Doctrine's ORM."}

{"answer":"yes","explanation":"Symfony Messenger's middleware pipeline allows you to inject custom middleware at any position, before or after the built-in ones, as demonstrated in transport configuration."}

{"answer":"no","explanation":"Symfony's release schedule is not fixed to major releases every two years and minor releases in May and November; in practice, major releases have varied (e.g., 4.0→5.0 was one year, 5.0→6.0 was three years), and minor stable releases have typically been released in November rather than in both May and November."}

{"answer": "8.3", "explanation": "Symfony 8, released in November 2024, requires a minimum PHP version of 8.3."}

{ ⏎   "answer": "no", ⏎   "explanation": "Symfony 7.0 removed support for docblock annotations for both validation and routes, leaving only PHP attributes (e.g., #[Route], #[Email]) as the supported mechanism." ⏎ }

{"answer": "no", "explanation": "AssetMapper is a PHP asset-management library for tasks like versioning, combining, and caching, but it does not operate via a mechanism called importmap.php; import maps are a browser JavaScript API, not a PHP file-based asset pipeline."}

{"answer": "no", "explanation": "Symfony 6.4 is actually a Long-Term Support (LTS) release, not a regular release without LTS; in Symfony's release cycle, the .4 minor versions (5.4, 6.4) are the LTS ones."}

{"answer": "no", "explanation": "Symfony removes features that were deprecated in the previous major version when you upgrade to the new one, which is the entire purpose of the deprecation cycle."}

{"answer": "yes", "explanation": "Symfony publishes an UPGRADE guide (e.g., UPGRADE-6.0.md) with each major release that documents deprecations, breaking changes, and removals."}

{"answer": "Asset Mapper", "explanation": "Symfony's Asset Mapper component (symfony/asset-mapper) manages assets and generates importmaps natively without requiring Node.js or webpack."}

{"answer": "no", "explanation": "Based on Symfony's typical annual release cadence, Symfony 7.0 shipped in November 2024, making 8.2 several years too early to have been released by November 2026."}

{ ⏎   "answer": "no", ⏎   "explanation": "Following Symfony's six-month cycle from 7.0 in May 2024, November 2026 would correspond to Symfony 8.1 (8.0 in May 2026, 8.1 in November 2026), not 8.2." ⏎ }

{"answer": "8.2", "explanation": "Symfony follows a predictable minor release pattern, so the version immediately following 8.1 is 8.2."}

{"answer": "no", "explanation": "Symfony 8.2 does not exist; the latest stable versions are in the 7.x series, and even major releases generally maintain backward compatibility rather than requiring full rewrites."}

{"answer": "yes", "explanation": "PHP guarantees backward compatibility for minor releases (8.1 → 8.2) within the same major version line, so no code changes are required."}

{"answer": "8.1", "explanation": "Symfony 8.1 was the last minor release in the 8.x branch before Symfony 9.0 (released in November 2025)."}

{"answer": "yes", "explanation": "Symfony 8.x has a minimum PHP requirement of 8.5, so moving to Symfony 8.2 does require upgrading PHP to at least 8.5."}

{"answer": "yes", "explanation": "Symfony's deprecation policy guarantees that deprecations introduced in the 8.x major version will not be removed until the next major version, 9.0."}

{"answer": "no", "explanation": "Twig's {{ }} tag supports expressions, function calls, and variable access but does not allow arbitrary PHP code or statements to be written directly in templates."}

{"answer": "yes", "explanation": "Twig has had auto-escaping enabled by default since version 1.14, so all printed variables are automatically HTML-escaped unless explicitly marked safe."}

{"answer":"yes","explanation":"The Twig |e filter (short for |escape) escapes a string for safe output in an HTML context by default."}

{"answer": "format_number", "explanation": "The twig/intl-extra extension provides a `format_number` filter that formats a number according to a specified locale."}

{"answer": "yes", "explanation": "The |raw filter (e.g., in Twig) marks a value as safe and prevents the template engine from applying auto-escaping to it."}

{"answer": "yes", "explanation": "In Twig, {{ }} outputs an expression value and {% %} executes template tags such as conditions, loops, and set."}

{ ⏎   "answer": "no", ⏎   "explanation": "Twig allows you to declare variables directly in a template using {% set %}, as well as through loop variables, macros, and other built-in constructs." ⏎ }

{"answer": "dump", "explanation": "The `dump()` Twig function outputs a debug representation of a variable's structure, such as arrays and objects."}

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JS library that provides pre-built UI components (buttons, forms, modals, etc.), not a Single Page Application (SPA) framework like React or Angular."}

```json ⏎ {"answer": "container-fluid", "explanation": "In Bootstrap, container-fluid is the class that provides a fully responsive fluid container, while container provides a responsive container with a fixed max-width per breakpoint; however the question describes the behavior of the container class."} ⏎ ```

{"answer": "no", "explanation": "The Bootstrap grid splits a row into 12 columns (not 16), and modern versions (Bootstrap 3.0 and later) use CSS floats for Bootstrap 3 but Flexbox from Bootstrap 4 onward."}

{"answer":"yes","explanation":"Bootstrap 4 and 5 define exactly five named breakpoints (sm, md, lg, xl, xxl) that appear as prefixes in utility and grid class names."}

{"answer": "yes", "explanation": "In Bootstrap, utilities like .mt-3 and .px-2 multiply $spacer by the number in the class name (e.g., mt-3 = 3 * $spacer)."}

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

{"answer":"yes","explanation":"Bootstrap 5 dropped its jQuery dependency and all its components are powered by vanilla JavaScript."}

{ ⏎   "answer": "yes", ⏎   "explanation": "In Bootstrap 5.2 and later, dark mode is enabled by adding the .dark class to the <html> (root) element." ⏎ }

{"answer": "no", "explanation": "Doctrine ORM does not create database tables on the fly; you must explicitly run migration or schema-creation commands to create tables."}

{"answer": "persist", "explanation": "EntityManager::persist() marks a new object as managed (in the persistent state) without executing any SQL until flush() is called."}

{"answer": "yes", "explanation": "In Doctrine ORM 3, EntityManager::merge() exists and makes a detached entity managed again by associating it with the persistence context of the EntityManager."}

{"answer": "yes", "explanation": "DQL (Domain Query Language) is an object-oriented query language that references entity classes and their persistent fields, not physical database tables and columns."}

{"answer": "null", "explanation": "In PHP frameworks like Doctrine and Laravel, the find() method returns null when no record matching the given ID exists."}

{"answer": "no", "explanation": "DoctrineBundle does not automatically call flush() at the end of every request; you must explicitly call $em->flush() (or configure auto-flush yourself) to persist changes to the database."}

{"answer": "yes", "explanation": "In Doctrine ORM, the Unit of Work tracks dirty state on managed entities, so modifying a property and calling flush() is sufficient to commit the change without needing persist() again."}

{"answer": "no", "explanation": "remove() only marks the entity for deletion; the actual DELETE SQL is executed during flush()."}

{"answer": "no", "explanation": "MVCC's purpose is the opposite: readers and writers do not block each other, since each transaction sees its own consistent version of the data."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command displays the query execution plan without actually running the query."}

{"answer": "no", "explanation": "SERIAL (a PostgreSQL pseudo-type) and GENERATED ... AS IDENTITY (the SQL standard mechanism) are related but distinct: SERIAL is a convenience type that creates an underlying sequence object alongside an integer column, while IDENTITY is a built-in column property with different enforcement semantics (e.g., GENERATED ALWAYS AS IDENTITY forbids manual value insertion). They are not simply two names for the same mechanism."}

{"answer": "no", "explanation": "In PostgreSQL, by default a UNIQUE constraint allows multiple rows with NULL values in the column, because NULL is not considered equal to NULL for uniqueness checks."}

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

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

{"answer": "PARTITION", "explanation": "The PARTITION BY clause in a window function defines how rows are partitioned into groups over which the function is computed."}

{"answer": "no", "explanation": "READ COMMITTED only protects against dirty reads; within a transaction, a row can be read, another transaction can commit a change to that row, and you will see the new value on a re-read, which is a non-repeatable read."}

{"answer": "yes", "explanation": "In PostgreSQL, each SQL statement is automatically wrapped in its own transaction (autocommit) unless explicitly started with BEGIN/START TRANSACTION."}

{"answer": "COMMIT", "explanation": "The COMMIT SQL command finalizes a transaction, making all changes made during that transaction permanent."}

{"answer": "yes", "explanation": "Indexes are used to speed up row-lookup in UPDATE and DELETE statements just as they are in SELECT, so a WHERE clause on an indexed column allows the engine to find matching rows without a full table scan."}

{"answer": "yes", "explanation": "SAVEPOINT creates a named checkpoint within a transaction, allowing you to roll back only the statements executed after that point while preserving earlier work."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and returns the plan with real execution statistics, whereas plain EXPLAIN shows the predicted plan without executing."}

{"answer": "pgvector", "explanation": "pgvector is a PostgreSQL extension that adds a vector data type and support for vector similarity indexes such as HNSW and IVFFlat, enabling embedding-based search."}

{"answer": "yes", "explanation": "A partial index in PostgreSQL only includes rows that satisfy the WHERE condition, making it more efficient than a regular index when queries primarily target the subset of matching rows."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using a snapshot taken at the start of the transaction and detects serialization violations at commit time by aborting conflicting transactions, rather than by locking the rows a transaction reads."}

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

{"answer": 204, "explanation": "HTTP 204 No Content indicates a successful request with an intentionally empty response body, which is the conventional status returned after a DELETE operation."}

{"answer": "yes", "explanation": "Per RFC 9110, DELETE is listed as an idempotent method: a second DELETE on an already-deleted resource produces no additional effect beyond the initial deletion (typically resulting in a 404)."}

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

{"answer":"yes","explanation":"HTTP 429 Too Many Requests is indeed used to indicate that a client has exceeded a rate limit or some other request constraint, and must back off before retrying."}

{"answer": "no", "explanation": "It is the opposite: 4xx codes indicate client errors and 5xx codes indicate server errors."}

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

{"answer": "no", "explanation": "RFC 5789 actually states that PATCH IS idempotent, because it specifies explicit operations to apply, so repeating the same operation set yields the same result."}

{"answer": "no", "explanation": "Plain == is vulnerable to timing attacks; PHP's hash_equals() should be used for constant-time comparison of password hashes."}

{"answer": "yes", "explanation": "This is the standard description of how CSRF protection works: the server generates the token, associates it with the user's session, and validates it on the server side for state-changing (unsafe) requests."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used by browsers to define a Content Security Policy, specifying allowed sources for loading web application resources."}

{ ⏎   "answer": "no", ⏎   "explanation": "OAuth 2.0 is an authorization framework (not an authentication protocol), and the access token is used to authorize resource access rather than to authenticate/identify the user." ⏎ }

{"answer": "no", "explanation": "XSS is prevented by output encoding/escaping when rendering data to the browser, not by input validation before storage, since stored data may later be displayed in different contexts requiring different encoding."}

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

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

{"answer": "no", "explanation": "A password salt is not required to be secret; it is typically stored alongside the hash, and its purpose is to ensure the same password produces a different hash each time, not to be a secret component needed for verification."}

{"answer": "no", "explanation": "PHPUnit requires test classes to extend PHPUnit\\Framework\\TestCase for its test discovery and execution mechanism to work."}

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

{"answer": "no", "explanation": "A data provider can yield multiple rows of arguments, causing the test to run once for each set of arguments."}

{"answer": "expectException", "explanation": "expectException is the PHPUnit TestCase method that declares an expectation that an exception of a specified class will be thrown during the test execution."}

{"answer": "no", "explanation": "It's the opposite: a mock verifies which methods were called (and can return data), while a stub only returns data without verification."}

{"answer": "yes", "explanation": "PHPUnit 10+ removed support for PHPDoc annotations entirely (including @dataProvider), making the #[DataProvider] attribute the required/recommended way to attach data to tests."}

{"answer": "no", "explanation": "PHPUnit does allow test dependencies via methods like dependsOnTest() and dependsOnTestCase(), which let a test depend on the result of another test."}

{"answer": "--random-order", "explanation": "The --random-order option was introduced in PHPUnit 11 to shuffle the order in which tests are executed."}

```json ⏎ {"answer": "3-3", "explanation": "intdiv(7,2) returns 3 and intdiv(-7,2) returns -3 (truncating division toward zero); the dot operator concatenates them as strings '3' and '-3' to produce '3-3'."} ⏎ ```

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

{"answer": "true", "explanation": "'1e1' is the numeric string 10.0 (scientific notation), and '10' is the numeric string 10.0, so the loose equality comparison is true, and the ternary operator outputs 'true'."}

{"answer": "other", "explanation": "In PHP 8+, the non-numeric string 'a' is compared to 0 by casting 0 to the string '0', and 'a' == '0' is false, so it falls through to the default case."}

{ ⏎   "answer": "2c", ⏎   "explanation": "strtr with an array searches for the longest matching key first; at position 0, 'ab' (length 2) matches and is replaced with '2', leaving 'c' which has no match, resulting in '2c'." ⏎ }

{"answer": "[]", "explanation": "substr('hello', -10) returns an empty string because the negative start position of -10 exceeds the length of the string 'hello' (5), so PHP returns an empty string, resulting in output '[]'."}

{"answer": "k,n,m", "explanation": "The + operator merges arrays with left-side values taking precedence for duplicate keys, so the result is ['k'=>1, 'n'=>2, 'm'=>3], whose keys are k, n, m joined by commas."}

{"answer":"yxz","explanation":"The array is sorted by the third element (values 1, 2, 2), giving order [2,'y',1], [1,'x',2], [3,'z',2]; then the second column ('y','x','z') is joined into the string 'yxz'."}

{"answer": 4, "explanation": "The spread operator with an associative array matches named arguments to parameters, so $a=5 and $b=1, giving 5-1=4."}

{"answer": "Parse error", "explanation": "The argument unpacking operator '...' in PHP must be followed by a variable (e.g., '$p->g(...$args)'), so '$p->g(...)' is a syntax/parse error and the script never runs."}

{"answer":"B","explanation":"static::class refers to the class in which the method was actually invoked (B), not the class where it was defined (A)."}

```json ⏎ {"answer": "10", "explanation": "In PHP 8.5 property hooks, the set hook uses $value for the incoming value (5) and $this->x to write to the backing store without re-triggering the hook, so $this->x = 5 * 2 = 10; since no get hook is defined, echo $c->x returns the backing-store value 10."} ⏎ ```

{"answer": "BA", "explanation": "TB::f insteadof TA makes f() return 'B', and TA::f as g renames TA's f() to g() returning 'A', so the concatenation produces 'BA'."}

{"answer": "0", "explanation": "In PHP, each class that uses a trait gets its own copy of static properties, so setting CX::$n does not affect CY::$n."}

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

{"answer": "second", "explanation": "When the finally block throws an exception, it replaces the originally thrown exception, so the LogicException('second') propagates up and is caught by the outer catch block."}

{"answer":"App\\Foo|Baz","explanation":"Baz::class returns the imported FQCN 'App\\Foo', and \\Baz::class returns 'Baz' from the global namespace."}

```json ⏎ {"answer": "noyes", "explanation": "class_exists('Foo') checks the global namespace (not the current one), so it returns false; class_exists('Ns\\Foo') finds the class in namespace Ns, returning true."} ⏎ ```

{"answer": "1,2,99", "explanation": "The foreach by reference leaves $v as a reference to the last element of $a, so setting $v = 99 modifies $a[2] from 3 to 99."}

{"answer": 3, "explanation": "The static variable $n belongs to class A and is shared across all instances of A and its subclasses (B does not redeclare it), so the calls increment the same counter: 1, 2, then 3."}

{"answer": "11", "explanation": "send(10) starts the generator, assigns 10 to $x at the yield point, then execution continues to return $x + 1 which is 11."}

{"answer": "1,2,ok", "explanation": "The yield from in outer() delegates to inner() yielding 1 and 2, then captures the return value 'ok' as $r, which outer() then yields, producing the sequence 1, 2, ok."}

{"answer": "noyes", "explanation": "The first password_needs_rehash call returns false (same cost 4), printing 'no', and the second returns true (higher cost 5), printing 'yes', giving 'noyes'."}

{"answer": "strict-in", "explanation": "2048 is E_COMPILE_WARNING, which is included in E_ALL, so (E_ALL & 2048) is 2048, not 0, making the condition false and outputting 'strict-in'."}

{"answer":"missing","explanation":"The sixth positional argument of Request::create() maps to $cookie, not $serverVars, so HTTP_X_TOKEN is never read into the headers and $r->headers->get('X-Token') returns null."}

{"answer": "BCA", "explanation": "Symfony EventDispatcher calls listeners in descending order of priority (10, 5, 0), so the listeners append B, C, A in that order."}

{ ⏎   "answer": "same", ⏎   "explanation": "Doctrine's identity map caches the entity after flush, so both find() calls return the same object reference from the map." ⏎ }

{"answer": 0, "explanation": "The entity is persisted and then removed before flush, so no INSERT is executed and the users table remains empty."}

{"answer": 1, "explanation": "COUNT(x) counts only non-NULL values, so the NULL row is excluded from the count."}

{"answer": "10,30,60", "explanation": "The window function sum(x) OVER (ORDER BY id) computes a running sum (10, 30, 60), and string_agg concatenates those text values with a comma separator."}

```json ⏎ {"answer": "M1M2", "explanation": "The middlewares execute in order (M1 then M2), each echoing its tag before delegating to the next; the final next() call on the empty stack throws an exception after both tags have been echoed."} ⏎ ```

{"answer": 11, "explanation": "Both handler descriptors are invoked in sequence, incrementing $n by 1 and then by 10, resulting in 11."}

{"answer": 1, "explanation": "The first INSERT adds row (1), the second INSERT is skipped due to the unique constraint with ON CONFLICT DO NOTHING, so the table contains exactly one row."}

{"answer": "2", "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, the constraint is not checked during the INSERT statements or the SELECT; it is only checked at COMMIT, so both rows are present when count(*) runs."}

{"answer": 6, "explanation": "The --filter regex 'test_sum' matches both test_sum and test_sum_abs, each with 3 data points, for a total of 6 tests."}

```json ⏎ {"answer": "2,1", "explanation": "The data provider returns two datasets [1] and [-1], so the test runs twice; it fails once because -1 > 0 is false."} ⏎ ```

{"answer": "POST", "explanation": "The -d flag in curl sends data to the server, which causes it to use the POST HTTP method by default."}

{"answer": "GET", "explanation": "The -G flag forces curl to use the GET method and appends the -d data as a query string, overriding the default POST behavior."}

{"answer": "invalid_client", "explanation": "RFC 6749 Section 5.1 defines \"invalid_client\" as the error returned when the client is not authorized (or does not exist), which applies to an unrecognized client_id at the token endpoint."}

{"answer": "fragment", "explanation": "In the OAuth 2.0 Implicit Grant flow (response_type=token), the authorization server returns the access_token in the fragment component of the redirect URI."}

{"answer": 6, "explanation": "The falsey value `false` is replaced by the default `2`, then multiplied by 3 to give 6."}

{ ⏎   "answer": "Twig\\Error\\SyntaxError", ⏎   "explanation": "The expression 'a' ~ 1 + 2 is parsed as ('a' ~ 1) + 2, giving 'a1' + 2, and Twig's + operator throws a SyntaxError when given a non-numeric string and a number." ⏎ }

{"answer": "1", "explanation": "The array [''] contains one empty string which violates the BlankNot constraint, producing one ConstraintViolation, so count() returns 1."}

{"answer": "Error", "explanation": "The class Symfony\\Component\\Form\\Forms does not exist (the correct class is FormFactoryBuilder), so calling Forms::createFormFactoryBuilder() throws a PHP Error, which is caught and its class name is echoed."}

{"answer": "same", "explanation": "Symfony's container returns the same singleton instance on repeated `get()` calls, so both `spl_object_id()` values are equal."}

{"answer":"It throws an exception: Could not resolve 'greeting!'", "explanation":"The placeholder %greeting!% refers to a parameter named 'greeting!', which does not exist (only 'greeting' is defined), so compile() fails."}

{"answer": "960px", "explanation": "In Bootstrap 5.3, at the 992px viewport the lg breakpoint applies, which sets the .container max-width to 960px."}

{"answer": "text-danger", "explanation": "In Bootstrap 5.3's text-color.scss, .text-danger is defined after .text-primary in the CSS cascade, so with equal specificity the later rule wins."}

{"answer": 2, "explanation": "The class is in the Domain layer, which can only depend on Domain, but it uses App\\Application\\PlaceOrder (Domain→Application) and App\\Infrastructure\\Db (Domain→Infrastructure), both of which violate the dependency rules."}

{"answer": 3, "explanation": "The Domain layer may only depend on Domain, but this class depends on Application (PlaceOrder) and Infrastructure twice (Db and Logger), giving 3 forbidden dependency edges."}

{"answer": "10,15", "explanation": "$a->amount is 10 and $c is a new Money instance with amount 15, so the concatenation produces 10,15."}

{"answer": 1, "explanation": "The remove('a') call throws a DomainException because there is only one item, and the exception is caught without removing 'a', so count() still returns 1."}

{"answer": "hi", "explanation": "The code creates an instance of class C, calls the hi() method which returns the string 'hi', and echoes it."}

{"answer": "yesno", "explanation": "Before accessing $o->v, the lazy ghost is uninitialized (outputs 'yes'); after accessing $o->v which triggers materialization via the callback, it is no longer uninitialized (outputs 'no')."}

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

{ ⏎   "answer": "nono", ⏎   "explanation": "AnnotationClassLoader was removed in Symfony 6.0, and AttributeClassLoader does not exist (the correct class name is AttributeLoader), so both class_exists checks return false on 8.1." ⏎ }