Карта знаний PHP — qwen3.8:latest, run-39 · think: medium

{"answer": "no", "explanation": "Double-quoted strings interpolate variables and interpret escape sequences (\\n, \\t, etc.), while single-quoted strings do not; the difference is functional, not merely speed."}

{"answer": "yes", "explanation": "The null coalescing operator (??) is syntactic sugar for isset($a) ? $a : $b, so it safely returns the default value without raising warnings or notices for undefined variables."}

{"answer": "ab", "explanation": "echo accepts multiple comma-separated arguments and concatenates them, so 'a' and 'b' print as 'ab'."}

{"answer": "yes", "explanation": "In PHP, print is a language construct that returns the integer 1, allowing it to be used within expressions, unlike echo which returns no value."}

{"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 ranked below + and -, so expressions like 1 + 2 . 3 are parsed as (1 + 2) . 3."}

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

{"answer": "3", "explanation": "In PHP, '.' and '+' have the same precedence and are left-associative, so it parses as ('sum: ' . 2) + 3, which is 'sum: 2' + 3, and the non-numeric string converts to 0, giving 3."}

{"answer": "no", "explanation": "With ===, arrays must have the same key/value pairs in the same order; order does matter for strict comparison."}

{"answer": "no", "explanation": "The comparison 0 == false actually returns true, and == is a loose (not strict) comparison; in PHP, 0 is cast to false so false == false is true."}

{"answer": "no", "explanation": "In PHP 8, when comparing a non-numeric string to a number, the number is cast to a string, so 'abc' == 0 becomes 'abc' == '0', which is false."}

{"answer": "no", "explanation": "Since PHP 8.0, null == 0 and null == '' both evaluate to false; only null == false remains true under loose comparison."}

{"answer": 42, "explanation": "Casting a string to int in PHP reads the leading numeric portion, so '42abc' becomes 42."}

{"answer": 10, "explanation": "PHP converts the string '5' to an integer, so the expression becomes 5 + 5 = 10."}

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

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

{"answer": "no", "explanation": "strrev() reverses a string byte-by-byte, which breaks multi-byte UTF-8 character sequences and produces garbled output."}

{"answer": "yes", "explanation": "The string 'Hello world' does contain the substring 'world', so str_contains() returns true."}

{"answer": "no", "explanation": "str_pad() accepts a third parameter $pad_type that allows STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH."}

{"answer": "no", "explanation": "By default, trim() strips spaces, tabs, newlines, carriage returns, null bytes, and vertical tabs (\" \\t\\n\\r\\0\\x0B\"), not just spaces."}

{"answer": 6, "explanation": "In UTF-8, 'é' is 2 bytes while the four ASCII characters are 1 byte each, totaling 6 bytes."}

{"answer": "def", "explanation": "substr with a negative start position of -3 begins 3 characters from the end, returning the last 3 characters 'def'."}

{"answer": "no", "explanation": "ucfirst() returns a new string with the first character uppercased; it does not modify the original string in place."}

{"answer": "yes", "explanation": "Heredoc (\"\"\" markers) allows variable interpolation, while nowdoc (''' markers) treats content like a single-quoted string with no interpolation."}

{"answer": "no", "explanation": "PHP's sort() reindexes array keys numerically; to preserve key-value associations you need asort() or ksort()."}

{"answer": "yes", "explanation": "In PHP, string array keys that represent valid integers (like '5') are automatically cast to integers."}

{"answer": "no", "explanation": "in_array() uses loose comparison (==) by default; strict comparison (===) must be explicitly enabled by passing true as the third argument."}

{"answer": "yes", "explanation": "Without a callback, array_filter() keeps only truthy values, effectively removing all falsy elements (false, 0, '', null, [], etc.)."}

{"answer": "no", "explanation": "The $preserve_keys parameter of array_slice() defaults to false, so keys are reindexed by default."}

{"answer": "[20, 30]", "explanation": "array_slice starts at index 1 (value 20) and takes 2 elements, yielding [20, 30]."}

{"answer": 2, "explanation": "The array union operator + keeps left-side keys, so 'a' remains 1 and 'b' is added, giving 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 introduced the array spread operator in array literals, and it works with both integer and string keys."}

{"answer": "no", "explanation": "In PHP, named arguments and the spread operator ...$args can be combined in a single function call, e.g. foo(a: 1, ...$args, c: 3)."}

{"answer": "no", "explanation": "In PHP, closures do not automatically capture variables from the outer scope; you must explicitly use the 'use' keyword to import them."}

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

{"answer": "no", "explanation": "An arrow function (fn) in PHP is limited to a single expression as its body and cannot use curly braces to contain multiple statements."}

{"answer": "no", "explanation": "PHP arrow functions (fn) capture outer variables by value at definition time, not by reference lazily at use time."}

{"answer": "yes", "explanation": "In PHP, a static closure explicitly does not bind or capture $this from the enclosing scope."}

{"answer": 5, "explanation": "The closure captures $x by value (not by reference) at definition time, so it retains the original value of 5 even after $x is reassigned to 7."}

{"answer": "yes", "explanation": "In weak typing mode (the default), PHP will coerce the numeric string \"5\" to the integer 5 when passed to an int-typed parameter; only strict_types mode would reject it with a TypeError."}

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, allowing properties to be declared directly in constructor parameters with visibility modifiers and type declarations."}

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

{"answer": "yes", "explanation": "In PHP, marking a method as final prevents any subclass from overriding it; attempting to do so results in a fatal error."}

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

{"answer": "class@anonymous", "explanation": "In PHP, an anonymous class created with 'new class {}' gets an internal name formatted as 'class@anonymous\\0/path/to/file.php:LINE', so the part before the NUL byte is 'class@anonymous'."}

{"answer": "yes", "explanation": "In PHP, private methods are not inherited and are not part of the inheritance contract, so a child class can freely define a method with the same name and any visibility without any restriction."}

{"answer": "no", "explanation": "__get() is called for both non-existent (undefined) properties AND inaccessible (protected/private) properties when accessed from outside the class."}

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

{"answer": "yes", "explanation": "In PHP, interfaces can declare constants, which are always implicitly public."}

{"answer": "instanceof", "explanation": "In PHP, the instanceof operator checks whether an object is an instance of a particular class or implements a particular interface."}

{"answer": "no", "explanation": "In PHP, interfaces can only declare method signatures (abstract methods) and constants; they cannot declare static methods because static methods require an implementation body, which interfaces do not allow."}

{"answer": "no", "explanation": "PHP's instanceof operator checks both class inheritance and interface implementation, not just class inheritance."}

{"answer": "no", "explanation": "In PHP, interface methods are always abstract and cannot have a body or default implementation; only traits (and abstract classes) can provide default method implementations."}

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared as public, protected, or default (which is public), but not private; therefore protected visibility is allowed."}

{"answer": 3, "explanation": "PHP's Foo::cases() returns an array containing all defined enum cases, and this enum has three cases (A, B, C)."}

{"answer": "yes", "explanation": "Since PHP 8.2, traits are allowed to declare constants in addition to methods and properties."}

{"answer": "yes", "explanation": "In PHP, both Exception and Error implement the Throwable interface, making it their common ancestor."}

{"answer": "no", "explanation": "TypeError extends Error (not Exception); both Error and Exception are siblings under Throwable, so catch(Exception $e) does not catch TypeError."}

{"answer": "no", "explanation": "The @ operator in PHP only suppresses errors (warnings, notices, deprecations) and does not suppress exceptions, which still propagate and require try/catch handling."}

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError, which extends ArithmeticError, which extends Error in PHP."}

{"answer": "no", "explanation": "The finally block always executes regardless of whether an exception was thrown or caught; it is not dependent on a catch block handling the exception."}

{"answer": "no", "explanation": "An exception thrown in a finally block suppresses/replaces any exception from the try block, so it does affect the overall result."}

{"answer": "yes", "explanation": "In PHP, casting any object (including a new Exception) to bool always yields true, as objects are never considered falsy."}

{"answer": "yes", "explanation": "Functions registered with register_shutdown_function() are executed during PHP's shutdown process, which is triggered by exit(), die(), normal script completion, and fatal errors."}

{"answer": "no", "explanation": "The 'use' statement only creates a compile-time alias for the fully-qualified class name; the actual file is loaded (via autoloading) only when the class is first referenced at runtime."}

{"answer": "function", "explanation": "In PHP, the syntax to import a function is `use function`, while `use const` is used to import a constant."}

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 strips the 'App\\' prefix, converts the remaining namespace separators to directory slashes, and appends the class name with .php, giving Controller/Api/UserController.php relative to src/."}

{"answer": "yes", "explanation": "Composer's vendor/autoload.php creates a ClassLoader instance and registers it with the SPL autoload stack via spl_autoload_register()."}

{"answer": "yes", "explanation": "__NAMESPACE__ is a PHP magic constant that returns the fully qualified name of the current namespace at compile time (an empty string if in the global namespace)."}

{"answer": "no", "explanation": "An unqualified class name in 'new' is resolved relative to the current namespace, not the global root; only a leading backslash forces global resolution."}

{"answer": "yes", "explanation": "PSR-4 strips the base namespace 'App\\', converts the remaining 'Model\\User' to a path 'Model/User.php', and prepends the base directory 'src/', yielding src/Model/User.php."}

{"answer": "no", "explanation": "In PHP, use (import) statements must be declared at the top level of a file or inside a namespace declaration; they cannot be placed inside a function body or any other inner scope."}

{"answer": "yes", "explanation": "In PHP, arrays are value types; assigning or passing them creates a copy (copy-on-write internally), not a reference, unless explicitly using the & operator."}

{"answer": 2, "explanation": "In PHP, arrays are copied by value on assignment, so modifying $b does not affect $a, which still contains 2 elements."}

{"answer": "yes", "explanation": "In PHP, variables defined in the global scope are not visible inside a function unless explicitly accessed via the global keyword, the $GLOBALS superglobal, or passed as function parameters."}

{"answer": "no", "explanation": "unset($GLOBALS['x']) inside a function removes the global variable entirely from the global scope, not just for that function's local scope."}

{"answer": 6, "explanation": "The function modifies $x by reference, so $n is incremented from 5 to 6."}

{"answer": "no", "explanation": "PHP's foreach creates an internal iterator that is independent of the array variable, so modifications to the array inside the loop body are not reflected in the ongoing iteration."}

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

{"answer": "no", "explanation": "In PHP, boolean array keys are cast to integers (true becomes 1, false becomes 0), so the key is stored as an integer, not a boolean."}

{"answer": "yes", "explanation": "Since PHP 5.5, a generator can use return with a value, which is retrievable via the Generator object's getReturn() method after the generator is complete."}

{"answer": "no", "explanation": "PHP generators are one-shot iterators; once fully consumed, they cannot be rewound or re-traversed."}

{"answer": "no", "explanation": "PHP has a yield keyword for generators but no 'yield from' construct; that is a Python feature."}

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

{"answer": 3, "explanation": "The generator yields 1, 2, 3 via yield from, iterator_to_array converts it to [1,2,3], and count returns 3."}

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

{"answer": "yes", "explanation": "ArrayIterator is a built-in PHP class that wraps an array and implements the Iterator interface (along with ArrayAccess and Countable), enabling traversal of the array."}

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

{"answer": "yes", "explanation": "password_hash() automatically generates and embeds a salt in the returned hash string; there is no parameter to supply one separately."}

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT is bcrypt ($2y$), not md5; it has been bcrypt since PHP 5.5."}

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

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags to help prevent XSS, but it does nothing to prevent SQL injection; that requires prepared statements or proper parameterized queries."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID, invalidating the old one, which prevents an attacker from exploiting a known (fixed) session ID after the user logs in."}

{"answer": "php_sapi_name()", "explanation": "php_sapi_name() is the built-in PHP function that returns the SAPI name, such as 'cli', 'apache2', or 'fpm-fcgi'."}

{"answer": "yes", "explanation": "session_destroy() only removes the session data on the server; the session cookie in the browser must be cleared separately with setcookie() using a past expiry date."}

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

{"answer": "8.1", "explanation": "The array_find() function was introduced in PHP 8.1 as part of a new set of array helper functions."}

{"answer": "no", "explanation": "PHP 8.4 introduced asymmetric visibility for properties, not property hooks (custom get/set logic in the property declaration)."}

{"answer": "no", "explanation": "The syntax `public private(set) string $name` is characteristic of C# (or similar languages), not PHP; PHP 8.4 introduced property hooks but not asymmetric visibility in that form."}

{"answer": "8.4", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.4, which was released in November 2024."}

{"answer": "none", "explanation": "PHP has no pipe operator (|>) in any released version; it is not a language feature."}

{"answer": "none", "explanation": "The 'clone-with' syntax (clone($obj, ['x' => 1])) was never implemented in any PHP version; it does not exist in PHP."}

{"answer": "not a real PHP function", "explanation": "array_first() and array_last() are not built-in PHP functions in any version; they are Laravel helper functions, not part of the PHP standard library."}

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

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

{"answer": "no", "explanation": "The Context Managers v2 RFC was still in the proposal/discussion stage and had not been voted on and adopted into the PHP core."}

{"answer": "no", "explanation": "There is no known PHP RFC titled 'Bound-Erased Generic Types' that was declined in 2026; this appears to be a fabricated reference."}

{"answer": "no", "explanation": "As of the known PHP release timeline, no RFC to make ZTS (Zend Thread-Safe) the default build has been accepted; PHP still defaults to NTS builds."}

{"answer": "yes", "explanation": "PHP has never included built-in generics (parameterized types); no RFC for them has been accepted as of PHP 8.5."}

{"answer": "yes", "explanation": "Following PHP's typical annual release cycle (8.4 in Nov 2024, 8.5 in Nov 2025, 8.6 in Nov 2026), if PHP 8.6's GA is 2026-11-19, then on 2026-11-07 the latest stable would indeed be 8.5."}

{"answer": "yes", "explanation": "PHP 6 was never released; the PHP team skipped directly from the 5.x series (5.6 being the last) to PHP 7.0 in December 2015."}

{"answer": "no", "explanation": "The RFC proposing a #[\\Deprecated] attribute was not adopted into PHP core as of the latest releases."}

{"answer": "yes", "explanation": "In clean/onion architecture, the dependency rule mandates that all source-code dependencies point inward toward the domain center, so inner layers are unaware of outer layers."}

{"answer": "yes", "explanation": "In Domain-Driven Design, domain entities are pure PHP objects with no dependencies on frameworks like Doctrine or Symfony, keeping the domain layer decoupled from infrastructure."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (or web/HTTP) layer, not the business-logic layer; they handle input/output and delegate business logic to services or use cases."}

{"answer": "Entities", "explanation": "In the Onion Architecture, the innermost layer at the very center contains the domain entities (business rules and core objects), with all other layers depending inward toward them."}

{"answer": "yes", "explanation": "Tools like deptrac can be configured with layer rules and will fail the build when a forbidden cross-layer dependency is detected."}

{"answer": "no", "explanation": "A use case (interactor) should depend on abstractions and plain domain objects, not on framework-specific types like an HTTP request or an EntityManager, to remain decoupled, testable, and framework-agnostic."}

{"answer": "Repository", "explanation": "A Repository provides a collection-like interface for accessing domain aggregates/entities while abstracting the underlying storage mechanism behind a common interface."}

{"answer": "yes", "explanation": "In Clean Architecture, the domain and use case layers depend only on abstractions (interfaces), so replacing PostgreSQL with another database only requires changing the outer infrastructure/adapter layer."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of domain objects treated as a single unit for consistency, which is a conceptual boundary and not synonymous with a database table (a technical persistence concern)."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a Value Object is defined by its immutability and value-based equality, meaning two instances with the same field values are considered equal regardless of identity."}

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

{"answer": "yes", "explanation": "In DDD, a Repository is defined per Aggregate Root, not per individual entity, ensuring encapsulation and that all access to internal entities goes through the root."}

{"answer": "yes", "explanation": "Ubiquitous Language in Domain-Driven Design is precisely the shared vocabulary that bridges developers and domain experts, ensuring everyone uses the same terms derived from the domain model."}

{"answer": "context", "explanation": "A context is the boundary within which a model and its language remain consistent in meaning, while outside it the same words refer to different models."}

{"answer": "no", "explanation": "DDD explicitly recommends a rich domain model where business logic lives inside entities and value objects, not in external service classes; the anemic model is considered an anti-pattern in DDD."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a Bounded Context ensures that the same real-world concept (e.g., 'Product', 'Customer') is modeled by its own dedicated class within each context, avoiding ambiguity."}

{"answer": "yes", "explanation": "Symfony's DI container stores service definitions (not instances) and only instantiates a service when it is first requested via get(), making it lazy by default."}

{"answer": "debug:router", "explanation": "The Symfony console command 'php bin/console debug:router' lists all registered routes in the application."}

{"answer": "no", "explanation": "Symfony autowiring (since 3.3) automatically resolves dependencies based on type hints, 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 caches the generated PHP files to avoid recompilation on subsequent requests."}

{"answer": "yes", "explanation": "In the Symfony dev environment, the DI container is compiled once and cached; it is only rebuilt when the timestamps of tracked configuration files change, not on every request."}

{"answer": "APP_ENV", "explanation": "In modern Symfony (4+), the APP_ENV environment variable selects the active environment such as dev, prod, or test."}

{"answer": "no", "explanation": "Symfony controller actions must be public methods; the router invokes them via reflection and will not call private or protected methods."}

{"answer": "no", "explanation": "In Symfony's EventDispatcher, both subscribers and listeners use the same numeric priority mechanism; a subscriber does not inherently fire before a listener—only the assigned priority value determines order."}

{"answer": "yes", "explanation": "Symfony 6.0 removed the legacy Guard system entirely, and authentication is now built around AuthenticatorInterface (and its subclasses) introduced in 5.3."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute in Symfony checks whether the current user has a specific role or permission, returning a 403 Forbidden response if they do not."}

{"answer": "yes", "explanation": "Symfony Voters are the built-in mechanism for making fine-grained, object-level access decisions, used via isGranted('EDIT', $post)."}

{"answer": "yes", "explanation": "Symfony 7 (requiring PHP 8.1+) removed support for the legacy Doctrine annotations reader; validation constraints must now be declared as native PHP 8 attributes like #[Assert\\NotBlank]."}

{"answer": "yes", "explanation": "Symfony's form component has CSRF protection enabled by default; a token is automatically generated, rendered in the form, and validated on submission."}

{"answer": "yes", "explanation": "Symfony always performs server-side form validation upon submission; HTML5 client-side checks are only a UX convenience and can be bypassed, so the server-side validation is the authoritative check."}

{"answer": "make:form", "explanation": "The Symfony MakerBundle command 'make:form' generates a FormType class for building forms."}

{"answer": "no", "explanation": "Symfony does not store the user's password in the session; the session holds only a serialized user identifier/token, while passwords are kept hashed in the database."}

{"answer": "yes", "explanation": "In Symfony (Flex-based projects, Symfony 4.1+), the recommended convention is to place one YAML file per bundle or topic in the config/packages/ directory."}

{"answer": "yes", "explanation": "This is a common and recommended pattern: a committed .env with safe dev defaults ensures new developers can bootstrap quickly, while .env.local (gitignored) holds real secrets."}

{"answer": "debug:container", "explanation": "The Symfony command 'debug:container' (invoked via bin/console debug:container) lists all registered services and their aliases in the DI container."}

{"answer": "no", "explanation": "The Symfony container is compiled and frozen after the build phase; parameters are baked into the generated class, so setParameter() cannot meaningfully change them at runtime."}

{"answer": "no", "explanation": "In Symfony, services are private (public: false) by default; you must explicitly set public: true to make them fetchable from the container."}

{"answer": "no", "explanation": "Many Symfony bundles work perfectly fine without any configuration file in config/packages; configuration is optional for most bundles."}

{"answer": "yes", "explanation": "Symfony uses the %env(VAR)% syntax to inject environment variable values into configuration files such as services.yaml."}

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

{"answer": "no", "explanation": "Symfony Messenger allows multiple handlers to be registered for the same message; they are executed sequentially, each receiving the same message instance."}

{"answer": "no", "explanation": "The sync transport handles the message immediately in the same process without any queueing; it is async transports that queue messages for a separate worker to consume."}

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

{"answer": "no", "explanation": "Retry strategy in Symfony Messenger is configured per message class (via the #[RetryableMessage] attribute) or as a global default, not per transport."}

{"answer": "yes", "explanation": "Symfony Messenger's default Serializer uses json_encode/json_decode to serialize and deserialize messages."}

{"answer": "yes", "explanation": "The Symfony Scheduler component is designed to schedule tasks and, when integrated with Messenger, produces ScheduledMessage objects that are dispatched through the Messenger transport at the specified intervals or times."}

{"answer": "doctrine", "explanation": "The Doctrine transport in Symfony Messenger stores messages in a database table managed by Doctrine ORM."}

{"answer": "yes", "explanation": "Symfony's Messenger allows you to add custom middleware at any position in the pipeline, before or after the built-in middleware such as validation, handling, and failure handling."}

{"answer": "yes", "explanation": "Symfony follows a predictable schedule with minor releases every six months (May and November) and major releases every two years (November)."}

{"answer": "8.4", "explanation": "Symfony 8 requires a minimum PHP version of 8.4."}

{"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations; only PHP 8 attributes are supported for validation, routing, and other features."}

{"answer": "yes", "explanation": "Symfony's AssetMapper component bundles, minifies, and manages CSS/JS assets using an importmap.php file, eliminating the need for Node.js or webpack."}

{"answer": "no", "explanation": "Symfony 6.4 is a Long-Term Support (LTS) release, supported until November 2027, not a regular non-LTS release."}

{"answer": "no", "explanation": "Symfony's versioning policy states that deprecations introduced in a major version are removed in the next major version, which is the primary purpose of a major release."}

{"answer": "yes", "explanation": "Symfony includes an UPGRADE-<major>.<minor>.md file in the repository for each major release, documenting all breaking changes and deprecations."}

{"answer": "AssetMapper", "explanation": "Symfony's AssetMapper component (introduced in 6.4/7.0) manages asset mapping and importmaps without requiring Node.js or Webpack."}

{"answer": "no", "explanation": "Symfony x.2 releases traditionally occur on the second Tuesday of November; in 2026 that is November 10, which is after November 7, so Symfony 8.2 would not yet be released on that date."}

{"answer": "no", "explanation": "Following Symfony's six-month cycle, Symfony 8.0 is May 2026, 8.1 is November 2026, and 8.2 would be May 2027, not November 2026."}

{"answer": 8.2, "explanation": "Following Symfony's semi-annual release cycle, 8.2 is the next minor version after 8.1, expected around November 2026."}

{"answer": "no", "explanation": "Symfony 8.2 does not exist (as of current releases, Symfony is in the 7.x line), and even major Symfony upgrades follow deprecation cycles rather than requiring a complete rewrite."}

{"answer": "yes", "explanation": "PHP guarantees backward compatibility between minor versions within the same major version (e.g., 8.1 → 8.2), so existing code should continue to work without changes."}

{"answer": "8.4", "explanation": "Following Symfony's release pattern (each major version has .0 through .4 minor releases, with .4 being LTS), the last minor version in the 8.x branch before Symfony 9.0 is 8.4."}

{"answer": "no", "explanation": "Symfony 8.2 does not exist; as of current releases, Symfony is in the 7.x line, so a requirement for a non-existent version is false."}

{"answer": "yes", "explanation": "Symfony's deprecation policy guarantees that features deprecated in a given major version (8.x) are kept until at least the next major release (9.0), so they will not be removed before Symfony 9.0."}

{"answer": "no", "explanation": "Twig's {{ }} delimiters only support Twig's own expression language (functions, filters, operators), not arbitrary PHP code execution."}

{"answer": "yes", "explanation": "Twig has auto-escaping enabled by default with the 'html' strategy to prevent XSS attacks."}

{"answer": "yes", "explanation": "The Twig |e (escape) filter defaults to HTML context, applying htmlspecialchars to safely output a string in HTML."}

{"answer": "localizednumber", "explanation": "The twig/intl-extra package provides the 'localizednumber' filter which uses the intl extension's NumberFormatter to format a number according to a given locale."}

{"answer": "yes", "explanation": "In Twig (commonly used with PHP frameworks like Symfony), the |raw filter tells the engine to output the value without applying auto-escaping."}

{"answer": "yes", "explanation": "In Twig, {{ }} outputs expressions (variables, function calls) while {% %} is used for structural tags such as if, for, and set."}

{"answer": "no", "explanation": "Twig allows you to declare variables inside a template using the {% set %} tag, e.g. {% set foo = 'bar' %}."}

{"answer": "dump", "explanation": "The Twig function `dump()` outputs the debug structure of a variable, similar to PHP's var_dump()."}

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JS toolkit providing ready-made UI components (buttons, modals, grid, etc.) and is not a Single Page Application framework like React, Angular, or Vue."}

{"answer": "container", "explanation": "The .container class in Bootstrap provides a responsive centered container with a fixed max-width that changes at each breakpoint (sm, md, lg, xl, xxl)."}

{"answer": "no", "explanation": "The Bootstrap grid splits a row into 12 columns (not 16), and modern Bootstrap (v4+) uses Flexbox rather than CSS floats."}

{"answer": "yes", "explanation": "In Bootstrap 5, the breakpoints are xs, sm, md, lg, xl, xxl, but xs has no infix in class names, leaving exactly five infixes: sm, md, lg, xl, xxl."}

{"answer": "yes", "explanation": "In Bootstrap, spacing utilities like .mt-3 or .px-2 compute their value as the number multiplied by the $spacer variable (e.g., 3 * 1rem)."}

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the data-bs-toggle attribute is used to enable interactive components such as dropdowns, tooltips, and modals on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 removed its jQuery dependency and all its interactive components are implemented in vanilla JavaScript (ES6+)."}

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

{"answer": "no", "explanation": "Doctrine ORM does not auto-create tables at runtime; tables must be created explicitly via migrations or schema-tool commands."}

{"answer": "persist", "explanation": "EntityManager::persist() transitions a new entity to the managed state and schedules an INSERT to be executed only when flush() is called."}

{"answer": "yes", "explanation": "EntityManager::merge() exists in Doctrine ORM 3 and its purpose is to merge the state of a detached entity into the managed context, effectively making it managed."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) operates at the ORM level, referencing entity names and their mapped fields rather than raw table and column names."}

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

{"answer": "yes", "explanation": "DoctrineBundle's auto_commit option defaults to true, which registers a listener on the kernel.response event that calls EntityManager::flush() at the end of each request."}

{"answer": "yes", "explanation": "The Unit of Work performs dirty checking on managed entities at flush() time, so modifying a property of an already-managed entity is automatically detected and committed without needing an explicit persist() call."}

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

{"answer": "no", "explanation": "MVCC is specifically designed so that readers do NOT block writers and writers do NOT block readers; readers see a snapshot of old versions while writers create new versions, eliminating that mutual blocking."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN SQL command displays the execution plan of a query without actually executing it."}

{"answer": "no", "explanation": "SERIAL creates a separate sequence object with a DEFAULT nextval() on the column, while GENERATED AS IDENTITY is a column-level constraint with an internally-managed sequence; they are different mechanisms with different behaviors and management, not two names for the same thing."}

{"answer": "no", "explanation": "In PostgreSQL, a UNIQUE constraint allows multiple rows with NULL because NULL is not considered equal to NULL, so each NULL is treated as a distinct value."}

{"answer": "string_agg", "explanation": "PostgreSQL's string_agg(expression, delimiter) aggregate function concatenates strings using the specified separator."}

{"answer": "no", "explanation": "Plain VACUUM only marks dead tuples as reusable within the table file; it does not shrink the file or return space to the OS (that requires VACUUM FULL)."}

{"answer": "PARTITION", "explanation": "In SQL window functions, the PARTITION BY clause divides rows into groups over which the window function is computed."}

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

{"answer": "yes", "explanation": "By default, PostgreSQL operates in autocommit mode, where each individual SQL statement is wrapped in its own implicit transaction and committed immediately upon success."}

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

{"answer": "yes", "explanation": "Indexes speed up row lookups for any query type (SELECT, UPDATE, DELETE) that filters on the indexed column, not just SELECT."}

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

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports real execution statistics; only plain EXPLAIN (without ANALYZE) shows the plan without executing the query."}

{"answer": "pgvector", "explanation": "pgvector is the PostgreSQL extension that adds a vector data type and index support (IVFFlat and HNSW) for similarity search on embeddings."}

{"answer": "yes", "explanation": "A partial index in PostgreSQL includes only rows that satisfy the WHERE predicate, saving space and improving query performance for those specific rows."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Snapshot Isolation with Serializable Snapshot Isolation (SSI), which detects conflicts after the fact via a dependency graph rather than by locking rows that a transaction reads."}

{"answer": "yes", "explanation": "HTTP status 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 where the server successfully processed it but is not returning any content in the response body, commonly used after DELETE requests."}

{"answer": "no", "explanation": "Per RFC 7231, DELETE is not listed as an idempotent method; a repeated DELETE on an already-deleted resource can yield a different response (e.g., 200 vs 404), so idempotency is not guaranteed."}

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

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests is specifically defined for rate limiting, indicating the client has sent too many requests in a given time frame."}

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

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not idempotent by default, whereas PUT is always idempotent by HTTP specification."}

{"answer": "no", "explanation": "Using plain == for hash comparison is vulnerable to timing attacks; PHP provides hash_equals() for constant-time comparison."}

{"answer": "yes", "explanation": "A CSRF token is generated by the server, stored in the session, included in unsafe requests (e.g., POST), and validated server-side to ensure the request originated from the legitimate user."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP response header allows website developers to mitigate cross-site scripting (XSS) and data injection attacks by controlling which resources the browser is allowed to load."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol, not an authentication protocol; the access token grants resource-access permissions but does not inherently identify who the user is (that role belongs to OpenID Connect / ID tokens)."}

{"answer": "no", "explanation": "XSS is primarily prevented by output encoding (escaping) when rendering data in the browser, not by input validation before storage; OWASP explicitly warns against relying on input validation alone to prevent XSS."}

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

{"answer": "yes", "explanation": "Refresh tokens are long-lived credentials used to obtain new access tokens without requiring the user to log in again."}

{"answer": "no", "explanation": "A salt does not need to be kept secret; it is typically stored in plaintext alongside the hash (e.g., in bcrypt's output), and the system's security relies on the hash algorithm, not the secrecy of the salt."}

{"answer": "no", "explanation": "PHPUnit requires test classes to extend PHPUnit\\Framework\\TestCase in order to be recognized and executed by the test runner."}

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

{"answer": "no", "explanation": "A data provider can supply multiple sets of arguments, allowing the test to run once per dataset, not just once."}

{"answer": "expectException", "explanation": "PHPUnit's expectException() method declares that an exception of the specified class is expected to be thrown during test execution."}

{"answer": "no", "explanation": "The definitions are reversed: a mock verifies method calls/interactions, while a stub simply returns predefined data."}

{"answer": "yes", "explanation": "PHPUnit 10 deprecated docblock annotations like @dataProvider in favor of PHP 8 attributes such as #[DataProvider]."}

{"answer": "no", "explanation": "PHPUnit allows test dependencies via the @depends annotation (or depends() method), which passes the return value of one test as an argument to another."}

{"answer": "--order-by=random", "explanation": "PHPUnit's --order-by option accepts the value 'random' to shuffle test execution order."}

{"answer": "3-4", "explanation": "intdiv(7,2) is 3 and intdiv(-7,2) is -4 (rounds toward negative infinity), concatenated as the string '3-4'."}

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

{"answer": "true", "explanation": "Both '1e1' and '10' are numeric strings, so PHP compares them numerically (1e1 = 10), making the expression true."}

{"answer": "zero", "explanation": "PHP's switch uses loose comparison (==), and 'a' == 0 is true because the non-numeric string 'a' is cast to 0."}

{"answer": "2c", "explanation": "strtr with an array sorts keys by length (longest first), so 'ab' is matched before 'a'; at position 0 it matches 'ab' → '2', then 'c' has no match, giving '2c'."}

{"answer": "[]", "explanation": "substr('hello', -10) returns an empty string because the negative offset (-10) exceeds the string length (5), so the result is '[' . '' . ']' which is '[]'."}

{"answer": "k,n,m", "explanation": "The array union (+) keeps 'k'=>'1','n'=>'2' from $a and adds 'm'=>'3' from $b, so array_keys gives ['k','n','m'] which implode turns into 'k,n,m'."}

{"answer": "yxz", "explanation": "usort orders by index 2 (values 1,2,2 → [2,'y',1], [1,'x',2], [3,'z',2]), then array_column extracts index 1 ('y','x','z') and implode concatenates to 'yxz'."}

{"answer": 4, "explanation": "The spread operator with an associative array passes named parameters, so f(...['b'=>1,'a'=>5]) is equivalent to f(a:5, b:1), returning 5-1=4."}

{"answer": 3, "explanation": "The first-class callable syntax $p->g(...) creates a closure bound to the object instance, so setting $p = null does not destroy the object; the closure still holds a reference and g() returns $this->v which is 3."}

{"answer": "B", "explanation": "static::class uses late static binding and resolves to the actual class of the instance (B), not the declaring class (A)."}

{"answer": 10, "explanation": "The set hook doubles the assigned value (5*2=10) and stores it in the backing store; the default getter returns that stored value 10."}

{"answer": "BA", "explanation": "TB::f insteadof TA makes f() return 'B', and TA::f as g aliases it so g() returns 'A', concatenating to 'BA'."}

{"answer": 0, "explanation": "Each class that uses a trait gets its own independent copy of static properties, so modifying CX::$n does not affect CY::$n, which remains 0."}

{"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": "Throwing a new exception in a finally block replaces the original exception, so the LogicException('second') propagates up and is caught by the outer catch block."}

{"answer": "App\\Foo|Baz", "explanation": "Baz::class resolves the use-alias to 'App\\Foo', while \\Baz::class refers to the global namespace class 'Baz'."}

{"answer": "noyes", "explanation": "class_exists('Foo') looks in the global namespace (not found → 'no'), while class_exists('Ns\\Foo') finds the class defined in namespace Ns (→ 'yes'), concatenated gives 'noyes'."}

{"answer": "1,2,99", "explanation": "After the foreach by reference, $v still references the last element of the array, so assigning 99 to $v changes the last element from 3 to 99."}

{"answer": 3, "explanation": "The static variable $n is a function-level static shared across all calls to inc(), so it increments to 1, 2, then 3 across the three calls regardless of which instance invokes it."}

{"answer": 11, "explanation": "send(10) assigns $x=10, then return $x+1 gives 11, which getReturn() retrieves."}

{"answer": "1,2,ok", "explanation": "yield from passes through inner's yields (1, 2), then the return value 'ok' is assigned to $r and yielded, producing 1, 2, ok."}

{"answer": "noyes", "explanation": "First check returns no (same cost 4), second check returns yes (different cost 5), so the output is 'noyes'."}

{"answer": "strict-out", "explanation": "In PHP 8.5, E_STRICT (2048) has been removed from E_ALL, so E_ALL & 2048 evaluates to 0, making the ternary return 'strict-out'."}

{"answer": "mapped", "explanation": "Symfony's Request::create converts the server parameter HTTP_X_TOKEN into the X-Token header, and HeaderBag::get is case-insensitive, so it returns 'abc'."}

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

{"answer": "same", "explanation": "Doctrine's EntityManager maintains an identity map (Unit of Work), so both find() calls return the exact same object instance already registered, making their spl_object_id values equal."}

{"answer": 0, "explanation": "Removing a newly persisted (not yet flushed) entity cancels the pending INSERT, so no row is ever written to the empty users table."}

{"answer": 1, "explanation": "COUNT(x) counts only non-NULL values in column x, so out of two rows (1 and NULL), it returns 1."}

{"answer": "10,30,60", "explanation": "The window function computes running sums (10, 30, 60), and string_agg concatenates them as text with commas in id order."}

{"answer": "M1M2", "explanation": "The middleware stack is called in order: M1 echoes 'M1' then delegates to M2, which echoes 'M2' before the final handler runs."}

{"answer": 11, "explanation": "Symfony Messenger's HandleMessageMiddleware calls all handlers registered for the message type, so $n is incremented by 1 (h1) and then by 10 (h2), giving 11."}

{"answer": 1, "explanation": "The first INSERT succeeds, the second is skipped due to the unique index conflict with ON CONFLICT DO NOTHING, so count(*) returns 1."}

{"answer": 2, "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, it is not enforced until the end of the transaction, so both INSERTs succeed and SELECT count(*) returns 2."}

{"answer": 6, "explanation": "The --filter 'test_sum' is a regex that matches both test_sum (3 data-set tests) and test_sum_abs (3 data-set tests), totaling 6 tests."}

{"answer": "2, 1", "explanation": "The data provider supplies two datasets ([1] and [-1]), so two tests run; the assertion $x > 0 passes for 1 but fails for -1, giving 1 failure."}

{"answer": "POST", "explanation": "The -d flag in curl sends data in the request body and implicitly sets the HTTP method to POST."}

{"answer": "GET", "explanation": "The -G flag tells curl to use the GET method, sending the -d data as a query string in the URL rather than as a POST body."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 §5.2, when the client cannot be authenticated (e.g., the client_id does not correspond to a registered client), the authorization server returns the error code 'invalid_client' with an HTTP 401 status."}

{"answer": "fragment", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access token is passed in the fragment (the part after '#') of the redirect_uri."}

{"answer": 0, "explanation": "The 'default' filter only applies to undefined values, not to defined falsy values like false, so false|default(2) yields false, and false * 3 evaluates to 0 via PHP type coercion."}

{"answer": "TypeError", "explanation": "Due to Twig's operator precedence, '~' binds tighter than '+', so 'a' ~ 1 + 2 is parsed as ('a' ~ 1) + 2, which becomes the string 'a1' + 2, causing a TypeError in PHP 8+."}

{"answer": 0, "explanation": "The array [''] is a non-empty array, so NotBlank passes and there are 0 violations."}

{"answer": "LogicException", "explanation": "Calling isValid() on a form that has not been submitted throws a \\LogicException, which is caught by the catch block and its class name is echoed."}

{"answer": "same", "explanation": "Symfony's container services are singletons by default, so calling get() twice returns the same instance, making the spl_object_id comparison true."}

{"answer": "hi Bob!", "explanation": "Symfony's ContainerBuilder resolves nested parameter references during compile(), so %greeting%! becomes 'hi Bob!'."}

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

{"answer": "text-danger", "explanation": "In Bootstrap 5.3, text-danger is defined later in the CSS than text-primary, so with equal specificity it wins by cascade order."}

{"answer": 2, "explanation": "The Domain class depends on both Application (PlaceOrder) and Infrastructure (Db), but Domain is only allowed to depend on Domain, resulting in 2 violations."}

{"answer": 3, "explanation": "The Domain layer may only depend on Domain, so each of the three dependencies on Application (PlaceOrder) and Infrastructure (Db, Logger) constitutes a separate violation."}

{"answer": "10,15", "explanation": "Money is immutable (readonly), so $a stays 10 and $c is a new Money with amount 15."}

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

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

{"answer": "yesno", "explanation": "The lazy ghost object is uninitialized before the property access (outputs 'yes'), and after accessing $o->v which triggers the initializer, it is no longer uninitialized (outputs 'no')."}

{"answer": "no", "explanation": "The Symfony Guard component (including AbstractGuardAuthenticator) was removed in Symfony 6.0, so it does not exist in Symfony 8.1."}

{"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 7.0 (deprecated in 6.4) and does not exist in 8.1, while AttributeClassLoader (the PHP 8 attributes replacement) is still present, so the output is 'no' followed by 'yes'."}