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

{"answer": "no", "explanation": "Double-quoted strings interpolate variables and process escape sequences, while single-quoted strings do not; the difference is functional, not just speed."}

{"answer": "yes", "explanation": "The null coalescing operator (??) uses isset() semantics, so it safely returns the right-hand value for undefined variables without raising any warnings."}

{"answer": "ab", "explanation": "echo accepts multiple comma-separated arguments and outputs them concatenated, so 'a' and 'b' produce 'ab'."}

{"answer": "no", "explanation": "While print does return 1, it is a language construct and cannot be used inside an expression (e.g., $x = 2 * print('hi') is a parse error)."}

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

{"answer": "yes", "explanation": "In PHP, the concatenation operator (.) has lower precedence than arithmetic operators like + and -, so 'a' + 1 . 'b' is parsed as ('a' + 1) . 'b'."}

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

```json ⏎ {"answer": 3, "explanation": "The concatenation operator '.' and '+' have the same precedence and are left-associative, so it parses as ('sum: ' . 2) + 3 = 'sum: 2' + 3, and the non-numeric string converts to 0, yielding 3."} ⏎ ```

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

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

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

{"answer": "yes", "explanation": "In PHP, null == 0, null == '', and null == false all evaluate to true under loose comparison."}

{"answer": 42, "explanation": "PHP's (int) cast parses leading numeric characters and stops at the first non-numeric character, so '42abc' becomes 42."}

{"answer": 10, "explanation": "In PHP, the + operator with a numeric string and an integer performs arithmetic addition, converting '5' to 5 and returning 10."}

{"answer": "no", "explanation": "When false is cast to a string in PHP, it becomes an empty string \"\", not \"0\"."}

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

{"answer":"no","explanation":"strrev() reverses a string byte-by-byte, which corrupts multi-byte UTF-8 characters."}

{"answer": "yes", "explanation": "str_contains('Hello world', 'world') returns true because the substring 'world' is found in 'Hello world'."}

{"answer": "no", "explanation": "str_pad() can pad on the left (STR_PAD_LEFT), right (STR_PAD_RIGHT), or both sides (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 encoded as 2 bytes, so the string 'héllo' is 1+2+1+1+1 = 6 bytes, and strlen() returns the byte length."}

{"answer": "def", "explanation": "substr('abcdef', -3) starts at position -3 (counting from the end) and returns the substring '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 supports variable interpolation like double-quoted strings, while nowdoc (with quoted delimiter) treats content as a plain string with no interpolation, similar to single-quoted strings."}

{"answer": "no", "explanation": "sort() reindexes the array with sequential integer keys; asort() is the function that preserves key-to-value associations."}

{"answer": "yes", "explanation": "PHP automatically casts string keys that represent valid integers to integer keys, so '5' is stored as the integer 5."}

{"answer": "no", "explanation": "in_array() uses loose comparison (==) by default; the $strict parameter defaults to false."}

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

{"answer": "no", "explanation": "By default, array_slice() reindexes keys starting from 0; preserving keys requires explicitly setting the fourth parameter (preserve_keys) to true."}

{"answer": [20, 30], "explanation": "array_slice starts at offset 1 (element 20) and takes 2 elements, returning [20, 30]."}

{"answer": 2, "explanation": "Array union (+) keeps left-side keys and only adds right-side keys not already present, so 'a' stays as 1 and 'b' is added, giving 2 elements."}

{"answer": "yes", "explanation": "The array spread operator was introduced in PHP 8.1 and supports both integer and string keys."}

```json ⏎ {"answer": "no", "explanation": "In PHP, named arguments can be combined with argument unpacking (e.g., foo(...$args, c: 3) is valid)."} ⏎ ```

{"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 number of arguments actually passed to the function (3), regardless of how many are declared in the signature."}

{"answer":"no","explanation":"Arrow functions (fn) in PHP can only have a single expression as their body; they cannot use curly braces with multiple statements."}

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

{"answer": "yes", "explanation": "A static closure in PHP does not bind to the current object scope, so $this is not available inside it."}

{"answer": 5, "explanation": "The closure captures $x by value (use ($x) without &), so it retains the value 5 from the time of closure creation, unaffected by the later reassignment to 7."}

{"answer": "yes", "explanation": "In weak typing mode (without strict_types=1), PHP will coerce the numeric string \"5\" to an integer when it is passed to an int-typed parameter."}

{"answer": "yes", "explanation": "Constructor property promotion was introduced in PHP 8.0, allowing parameters in __construct to be declared with visibility modifiers to automatically create and assign properties."}

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

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

{"answer": "no", "explanation": "Private properties are only accessible within the class where they are defined, not in subclasses."}

{"answer": "class@anonymous", "explanation": "Anonymous classes in PHP get the name 'class@anonymous' followed by a NUL byte and then the file path/line number."}

```json ⏎ {"answer": "yes", "explanation": "Private methods are not inherited in PHP, so a child class is free to declare a same-named method with any visibility without triggering a fatal error."} ⏎ ```

{"answer": "no", "explanation": "__get() is called for both non-existent and inaccessible (e.g., private/protected) properties, not only non-existent ones."}

{"answer": "Error", "explanation": "Reassigning a readonly property throws a TypeError, which is a subclass of Error (not Exception) in PHP's hierarchy."}

{"answer": "yes", "explanation": "In PHP, interfaces can declare public constants, which are accessible both on the interface itself and on implementing classes."}

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

{"answer": "no", "explanation": "PHP interfaces can only declare abstract (implicitly public, non-static) methods; declaring a static method in an interface results in a fatal error."}

{"answer": "no", "explanation": "The instanceof operator in PHP checks both class inheritance and interface implementation; it returns true if the object is an instance of the class or implements the interface."}

{"answer": "no", "explanation": "Interface methods in PHP must be abstract (no body); they cannot have a default implementation, unlike trait methods."}

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared as public or protected, but not private."}

{"answer": 3, "explanation": "The enum Foo defines three cases (A, B, C), so Foo::cases() returns an array with 3 elements."}

{"answer": "yes", "explanation": "PHP traits can declare constants, which are then accessible within any class that uses the trait."}

{"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 Exception and Error are siblings extending Throwable, so catch(Exception) will not catch TypeError."}

{"answer": "no", "explanation": "The @ operator suppresses errors, warnings, and notices, but it does not suppress exceptions; exceptions still propagate regardless of @."}

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

{"answer": "no", "explanation": "The finally block always runs regardless of whether an exception was thrown, caught, or not — it is guaranteed to execute in all cases."}

{"answer": "no", "explanation": "An exception thrown in a finally block actually replaces (overrides) any exception that was propagating from the try/catch block, so it does have an effect."}

{"answer": "yes", "explanation": "In PHP, casting any object to boolean always results in true."}

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

{"answer": "no", "explanation": "The use statement is a compile-time alias that simply maps a short name to a fully qualified class name; the class file is only loaded via the autoloader when the class is actually instantiated or a static member is accessed."}

{"answer": "function", "explanation": "In PHP, you use 'use function' to import a function from another namespace, while 'use const' is for importing constants."}

```json ⏎ {"answer": "src/Controller/Api/UserController.php", "explanation": "PSR-4 maps each sub-namespace segment to a directory and the class name to a .php file relative to the base path src/."} ⏎ ```

{"answer": "yes", "explanation": "Composer's vendor/autoload.php generates a unique autoloader class that internally calls spl_autoload_register() to register its ClassLoader."}

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

{"answer": "no", "explanation": "In a namespaced context, an unqualified class name is first resolved relative to the current namespace, and only falls back to the global namespace if not found there."}

{"answer": "yes", "explanation": "PSR-4 maps the remaining namespace segments (Model\\User) to subdirectories and the class name to the filename, resulting in src/Model/User.php."}

{"answer": "no", "explanation": "In PHP, use statements (for namespaces, functions, or constants) must be declared at the top level of a file or within a namespace declaration; they cannot be placed inside a function body."}

{"answer": "yes", "explanation": "In PHP, assigning an array to another variable creates a copy (using copy-on-write for efficiency), not a reference to the original array."}

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

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

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

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

{"answer": "no", "explanation": "A foreach by value iterates over an internal copy of the array, so modifications to the array inside the loop are not visible during the same pass."}

{"answer": "no", "explanation": "Static properties belong to the class, not to individual instances, so all instances share the same value and changes are visible across all objects."}

{"answer": "no", "explanation": "In PHP, boolean array keys are cast to integers: true becomes 1 and false becomes 0."}

{"answer": "yes", "explanation": "In PHP, a generator can use 'return $value' to set a return value retrievable via $gen->getReturn()."}

{"answer": "no", "explanation": "Generators in PHP are single-use; once fully consumed they are closed and cannot be rewound or iterated again."}

{"answer": "no", "explanation": "PHP does not have a 'yield from' construct; that is a Python feature. PHP only has 'yield' for generators."}

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

```json ⏎ {"answer": 3, "explanation": "yield from [1, 2, 3] yields three values (1, 2, 3), iterator_to_array converts them to an array of 3 elements, and count returns 3."} ⏎ ```

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

{"answer": "yes", "explanation": "ArrayIterator is a built-in PHP class that wraps an array and implements the Iterator interface, allowing traversal via current(), key(), next(), rewind(), and valid() methods."}

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

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

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT is bcrypt (PASSWORD_BCRYPT), not md5."}

{"answer": "yes", "explanation": "password_verify checks if the plain text matches the hash, and since the hash was generated from the same string 'secret', it returns true."}

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags and is related to XSS mitigation, not SQL injection; prepared statements or parameterized queries are used to prevent SQL injection."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID, preventing an attacker from using a previously known (fixed) session ID after the user logs in."}

{"answer": "php_sapi_name", "explanation": "The built-in function php_sapi_name() returns the SAPI name, such as 'cli' for command-line interface."}

{"answer": "yes", "explanation": "session_destroy() only destroys the session data on the server; the session cookie in the browser must be manually cleared with setcookie() using an expired timestamp."}

{"answer": "no", "explanation": "session_start() must be called to retrieve and populate $_SESSION with previously stored session data; without it, $_SESSION remains empty."}

{"answer": "not a built-in PHP function", "explanation": "array_find() does not exist in PHP's standard library as of any released version."}

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

{"answer": "yes", "explanation": "Asymmetric visibility (e.g., public private(set) string $name) was indeed introduced in PHP 8.4."}

{"answer": 8.4, "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.4 to flag cases where a function's return value is discarded."}

{"answer": "it does not exist in any PHP version", "explanation": "PHP has no pipe operator '|>'; this operator is found in languages like F# but was never introduced in PHP."}

{"answer": "no", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) does not exist in any PHP version; PHP's clone keyword does not accept a second argument."}

{"answer": "never", "explanation": "array_first() and array_last() are not built-in PHP functions in any version; PHP 8.0 introduced array_key_first() and array_key_last() instead."}

{"answer": "8.4", "explanation": "The RFC for first-class callable syntax (partial function application) was adopted for PHP 8.4."}

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

{"answer": "no", "explanation": "There is no evidence that a 'Context Managers v2' RFC was adopted in PHP; while context/scoped-value discussions have existed, this specific RFC was not accepted."}

```json ⏎ {"answer": "yes", "explanation": "PHP has consistently rejected generics RFCs, including the Bound-Erased Generic Types proposal, as the community prefers other approaches like templates and existing type systems."} ⏎ ```

{"answer": "no", "explanation": "As of 2026, no RFC enabling ZTS (Zend Thread Safety) by default has been accepted in PHP; the default build remains NTS (Non-Thread Safety)."}

{"answer": "yes", "explanation": "PHP has never implemented built-in generics (parameterized types), and no such feature is planned or accepted for PHP 8.5."}

```json ⏎ {"answer": "yes", "explanation": "PHP follows an annual November release cycle; PHP 8.5 would have GA'd in November 2025 and PHP 8.6 is expected in November 2026, making 8.5 the latest stable as of 2026-11-07."} ⏎ ```

{"answer": "yes", "explanation": "PHP 6 was never released; the version following PHP 5.6 was PHP 7.0."}

{"answer": "no", "explanation": "The RFC for a #[\\Deprecated] attribute was not accepted; PHP continues to rely on @deprecated docblock annotations for marking deprecations."}

{"answer": "yes", "explanation": "The dependency rule in Clean/Onion Architecture states that source code dependencies must always point inward toward the center (the domain), meaning inner layers must not depend on outer layers."}

{"answer": "yes", "explanation": "Domain entities should be pure PHP classes free of framework dependencies, relying only on the language and standard library, to maintain a clean, framework-agnostic domain layer."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation/interface layer, not the business-logic layer; they simply call use cases to translate between HTTP and the application."}

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

{"answer": "yes", "explanation": "Deptrac and similar tools analyze inter-layer dependencies and report a failure when a forbidden dependency rule is violated, enabling automated enforcement of layer boundaries."}

{"answer": "no", "explanation": "A use case should be decoupled from infrastructure; it should work with domain entities and use ports/abstractions, not concrete HTTP requests or EntityManagers."}

{"answer": "Repository", "explanation": "The Repository pattern provides a collection of aggregates/entities while hiding the storage mechanism behind an interface, acting like an in-memory collection of domain objects."}

{"answer": "yes", "explanation": "In Clean Architecture, the database is an outermost-layer detail (framework/driver) that implements a port defined by the use cases; swapping it doesn't affect the domain or use case logic."}

{"answer": "no", "explanation": "An aggregate in DDD is a consistency boundary around a cluster of domain objects, not a database table; it's a conceptual model, not a persistence mapping."}

{"answer": "yes", "explanation": "By definition in Domain-Driven Design, a Value Object is immutable and two instances are considered equal if their field values are the same, not based on object identity."}

{"answer": "Aggregate Root", "explanation": "In DDD, the Aggregate Root is the single entry point through which all external changes to an aggregate must pass."}

{"answer": "yes", "explanation": "In DDD, a repository is defined per aggregate root to ensure aggregate invariants are maintained and entities are accessed through the root."}

{"answer": "yes", "explanation": "Ubiquitous language is a Domain-Driven Design concept where the model's terms are shared consistently between developers and domain experts."}

{"answer": "paradigm", "explanation": "A paradigm is the boundary within which a model and its language are self-consistent, while outside it the same terms may refer to different models or frameworks."}

{"answer": "no", "explanation": "DDD recommends rich domain models where business logic is encapsulated in entities and value objects, not separated into service layers."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a Bounded Context defines a boundary within which a specific model is valid, so the same real-world concept can be modeled as a different class in different contexts."}

{"answer": "yes", "explanation": "Symfony's DI container instantiates services lazily by default, meaning they are only created when first requested via the container."}

{"answer": "debug:router", "explanation": "The Symfony console command to list all registered routes is debug:router (formerly router:debug)."}

{"answer": "no", "explanation": "Autowiring automatically resolves service 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 optimized PHP classes and caches them to avoid recompilation on subsequent requests."}

{"answer": "yes", "explanation": "In the dev environment, Symfony caches the compiled container and only rebuilds it when tracked files (e.g., service configs) have changed, not on every request."}

{"answer": "APP_ENV", "explanation": "Since Symfony 4, the APP_ENV environment variable selects the active environment (e.g., dev, prod, test)."}

{"answer": "no", "explanation": "Symfony controller methods must be public; the framework's controller resolver will not invoke private or protected methods."}

{"answer": "no", "explanation": "Subscribers and listeners are the same mechanism; priority is determined by the numeric priority value, not by whether a listener is defined via a subscriber class."}

{"answer": "yes", "explanation": "Symfony 6.0 removed the legacy Guard authentication system, making the AuthenticatorInterface-based system the sole authentication mechanism."}

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

{"answer": "yes", "explanation": "Voters in Symfony are used to check access rights on specific objects, and isGranted('EDIT', $post) is the standard way to invoke them."}

{"answer": "yes", "explanation": "Symfony 7 removed support for Doctrine Annotations in validation; PHP attributes (#[Assert\\NotBlank]) are the only supported way to declare constraints."}

{"answer": "yes", "explanation": "Symfony enables CSRF protection for forms by default; a token is automatically generated and validated on submission unless explicitly disabled."}

{"answer": "yes", "explanation": "Symfony always performs server-side form validation regardless of client-side HTML5 checks, as client-side validation is only for UX and must never be trusted."}

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

{"answer": "no", "explanation": "Symfony hashes passwords (e.g., with bcrypt/argon2) and stores only a token or serialized user object in the session, never the plain-text password."}

{"answer": "yes", "explanation": "In Symfony, bundle configuration files are conventionally placed in config/packages/, with one file per bundle or topic (e.g., framework.yaml, doctrine.yaml)."}

{"answer": "yes", "explanation": "This is a common and recommended practice: commit a .env with safe dev defaults for reference, and keep real secrets in a non-committed .env.local (or similar) that overrides them."}

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

```json ⏎ {"answer": "no", "explanation": "The Symfony container is designed to be immutable once compiled; setParameter() is not part of the ContainerInterface contract and modifying parameters at runtime is not supported or reliable."} ⏎ ```

{"answer": "no", "explanation": "Since Symfony 4.1, services are private by default (public: false), meaning they cannot be fetched directly from the container unless explicitly marked as public."}

{"answer": "no", "explanation": "Many bundles work out of the box with default settings; a configuration file in config/packages is optional, not mandatory."}

{"answer": "yes", "explanation": "In Symfony, the %env(VAR_NAME)% syntax is used to reference environment variables in configuration files such as services.yaml."}

{"answer": "APP_DEBUG", "explanation": "APP_DEBUG is the Symfony environment variable that, when set to true, enables debug mode, activating the profiler and Twig debug features."}

{"answer": "no", "explanation": "Symfony Messenger allows multiple handlers to be registered for the same message, and they will all be invoked in the order they are defined."}

{"answer": "no", "explanation": "The sync transport handles the message immediately in the same process, it does not queue it for a worker like async transports do."}

{"answer": "messenger:consume", "explanation": "The bin/console messenger:consume command starts the worker that listens to a Messenger transport and processes queued messages."}

{"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy (max_retries, multiplier, delay, max_delay) is defined under each individual transport in the configuration."}

{"answer": "yes", "explanation": "Symfony Messenger uses the Serializer component with JSON encoding as its default serialization format."}

{"answer": "yes", "explanation": "Symfony Scheduler is designed to produce messages on a schedule and dispatch them through the Messenger component."}

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

{"answer": "yes", "explanation": "Laravel's Messenger pipeline supports custom middleware that can be registered before or after the built-in ones."}

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

{"answer": "8.4", "explanation": "Symfony 8 requires PHP 8.4 as the minimum version."}

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

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

{"answer": "yes", "explanation": "Symfony does not have a formal LTS program; all minor versions (including 6.4) follow the same support policy of 2 years of bug fixes and 3 years of security fixes."}

```json ⏎ {"answer": "no", "explanation": "Major releases in Symfony remove deprecated features; that is the core purpose of a major version bump following SemVer."} ⏎ ```

{"answer": "yes", "explanation": "Symfony provides UPGRADE-*.md files in each major version's repository documenting all changes, deprecations, and breaking changes."}

{"answer": "AssetMapper", "explanation": "Symfony's AssetMapper component (introduced in 6.4) manages assets and importmaps without requiring Node.js or webpack."}

```json ⏎ {"answer": "no", "explanation": "Following Symfony's 6-month release cycle, Symfony 8.0 would be the expected release around November 2026, making 8.2 still far in the future."} ⏎ ```

{"answer": "yes", "explanation": "Symfony follows a six-month release cycle where even minor versions (x.2) are released in November, so 8.2 is indeed scheduled for November 2026."}

{"answer": "8.2", "explanation": "Following Symfony's minor versioning scheme, the version immediately after 8.1 is 8.2."}

```json ⏎ {"answer": "no", "explanation": "Symfony 8.2 does not exist, and even major Symfony releases provide upgrade paths rather than requiring full rewrites."} ⏎ ```

{"answer": "yes", "explanation": "PHP follows backward compatibility for minor version updates (e.g., 8.1 → 8.2), so no breaking code changes are required."}

{"answer": "8.4", "explanation": "Following Symfony's established pattern (4.4, 5.4, 6.4, 7.4), the last minor release in the 8.x branch before Symfony 9.0 is 8.4."}

{"answer": "no", "explanation": "Symfony 8.2 does not exist and PHP 8.5 has not been released, so this is a fabricated claim about future versions."}

{"answer": "yes", "explanation": "Symfony guarantees that deprecations introduced in a given major version will not be removed before the next major version, so 8.x deprecations are only removed in 9.0."}

{"answer": "no", "explanation": "Twig does not allow calling arbitrary PHP functions inside {{ }}; it only permits its own built-in functions, filters, and explicitly registered extension functions."}

{"answer": "yes", "explanation": "Twig automatically escapes printed variables by default using the 'html' escaping strategy to prevent XSS attacks."}

{"answer": "yes", "explanation": "The Twig |e (escape) filter escapes a string for safe output, and its default context is HTML."}

{"answer": "number_format", "explanation": "The number_format filter from twig/intl-extra formats a number according to a given locale using PHP's NumberFormatter."}

{"answer": "yes", "explanation": "The |raw filter (used in Twig/Laravel Blade) outputs a value without HTML-escaping, effectively disabling auto-escaping."}

{"answer": "yes", "explanation": "In Twig, {{ }} is for outputting expression values, while {% %} is for executing statements and control structures like if, for, set, etc."}

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

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

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JS library providing reusable UI components and utilities, not an SPA framework like Angular, React, or Vue."}

{"answer": "container", "explanation": "The .container class in Bootstrap provides a responsive fixed-width container with max-width values that change at each breakpoint."}

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

{"answer": "yes", "explanation": "Bootstrap 5 defines five named breakpoints with infixes: sm, md, lg, xl, and xxl."}

{"answer": "yes", "explanation": "In Bootstrap, spacing utilities like .mt-3 or .px-2 multiply the base $spacer variable by the number in the class name."}

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

{"answer": "yes", "explanation": "Bootstrap 5 removed its jQuery dependency and all components are now built with plain vanilla JavaScript (ES6+)."}

{"answer": "no", "explanation": "In Bootstrap 5, dark mode is enabled with the data-bs-theme=\"dark\" attribute, not a .dark class."}

{"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; you must explicitly use tools like Doctrine Migrations or SchemaTool to create or update the database schema."}

{"answer": "persist", "explanation": "EntityManager::persist() marks a new entity as managed, deferring the SQL INSERT until flush() is called."}

{"answer": "no", "explanation": "EntityManager::merge() was removed in Doctrine ORM 3; it was deprecated in 2.x and eliminated in 3.0."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is an object-oriented query language that operates on entities and their fields, unlike SQL which works with tables and columns."}

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

```json ⏎ {"answer": "yes", "explanation": "DoctrineBundle has auto_commit enabled by default, which triggers a flush() at the end of each request via a kernel.response event listener."} ⏎ ```

{"answer": "yes", "explanation": "Doctrine's Unit of Work performs dirty checking by comparing the current state of managed entities to their snapshot, so flush() will detect and persist property changes without an explicit persist() call."}

{"answer": "no", "explanation": "Doctrine's remove() only schedules the entity for deletion in the UnitOfWork; the actual SQL DELETE is executed upon flush()."}

{"answer": "no", "explanation": "MVCC in PostgreSQL is designed so that readers do NOT block writers and writers do NOT block readers; that's the whole point of multi-version concurrency control."}

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

{"answer": "no", "explanation": "SERIAL is a PostgreSQL-specific shortcut that creates a separate sequence object and a DEFAULT clause, while GENERATED AS IDENTITY is a SQL-standard column property with different management (ALTER COLUMN SET/DROP IDENTITY) and different underlying semantics."}

{"answer": "no", "explanation": "In PostgreSQL, NULL values are considered distinct from each other, so a UNIQUE constraint allows multiple rows with NULL in the column."}

{"answer": "string_agg", "explanation": "string_agg(expression, delimiter) is the PostgreSQL aggregate function that concatenates strings with a specified separator."}

{"answer": "no", "explanation": "Plain VACUUM only marks dead tuples as reusable within the table file; it does not return space to the OS. VACUUM FULL is required for that."}

{"answer": "PARTITION", "explanation": "The PARTITION BY clause in a window function definition 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 starting at the REPEATABLE READ level."}

{"answer": "yes", "explanation": "PostgreSQL operates in autocommit mode by default, meaning each SQL statement is wrapped in its own implicit transaction and committed immediately unless explicitly within a BEGIN/COMMIT block."}

{"answer": "COMMIT", "explanation": "The COMMIT SQL command ends a transaction by permanently saving all changes made within it."}

{"answer": "yes", "explanation": "Indexes are used to quickly locate rows for any query type (SELECT, UPDATE, DELETE) that involves searching on the indexed column."}

{"answer": "yes", "explanation": "SAVEPOINT allows rolling back to a specific point within a transaction, undoing only the statements executed after that savepoint."}

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

{"answer": "pgvector", "explanation": "pgvector is a PostgreSQL extension that adds a vector data type and index types for efficient similarity search on embeddings."}

{"answer": "yes", "explanation": "A partial index in PostgreSQL includes only the rows that satisfy the specified WHERE condition, reducing index size and improving performance for targeted queries."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), a predicate-based conflict detection mechanism, not by locking rows that are read."}

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

{"answer": 204, "explanation": "HTTP 204 No Content indicates a successful request with no response body, commonly returned after DELETE operations."}

```json ⏎ {"answer": "yes", "explanation": "RFC 7231 §4.2 lists DELETE among the methods intended to have stable and predictable side effects, i.e., idempotent, though it notes this is not guaranteed in every implementation."} ⏎ ```

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

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests was introduced in RFC 6585 specifically to indicate that a client has sent too many requests in a given time frame (rate limiting)."}

{"answer": "no", "explanation": "It's the opposite: 4xx codes indicate client errors and 5xx codes indicate server-side 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 defines PATCH as a partial modification method that is not idempotent, whereas PUT is required to be idempotent per RFC 9110."}

{"answer": "no", "explanation": "Using == is vulnerable to timing attacks and type juggling (e.g., 0e-hash strings compared as equal to 0); hash_equals() or password_verify() should be used instead."}

{"answer": "yes", "explanation": "CSRF tokens are indeed server-generated, session-bound, and validated on the server side for unsafe HTTP methods like POST, PUT, DELETE."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to enable and define a CSP policy for a web application."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol, not an authentication protocol; the access token grants permission to access resources, and identifying the user is the role of OpenID Connect or identity tokens."}

{"answer": "no", "explanation": "XSS is prevented by encoding/escaping output when rendering data to the browser, not by validating input before storing it in the database."}

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

{"answer": "yes", "explanation": "Refresh tokens are designed to outlive access tokens and enable obtaining new access tokens without re-authenticating the user."}

{"answer": "no", "explanation": "A salt does not need to be secret; it is typically stored alongside the hash. Its purpose is to ensure identical passwords produce different hashes (defeating rainbow tables), not to provide secrecy."}

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

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

{"answer": "no", "explanation": "A data provider can yield multiple sets of arguments, allowing the test to run multiple times with different data."}

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

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

{"answer": "yes", "explanation": "PHPUnit 10+ recommends the #[DataProvider] attribute over the deprecated @dataProvider docblock annotation."}

{"answer": "no", "explanation": "PHPUnit supports test dependencies via the @depends annotation or the depends() method, allowing one test to rely on the result of another."}

{"answer": "--random-order", "explanation": "The --random-order option shuffles the order of test classes and test methods in PHPUnit."}

{"answer": "3-3", "explanation": "intdiv(7,2) is 3 and intdiv(-7,2) is -3 (truncates toward zero), concatenated as a string gives '3-3'."}

{"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, thus 10 == 10 is true."}

{"answer": "other", "explanation": "In PHP 8+, a non-numeric string like 'a' does not loosely equal the integer 0, so the default case is executed."}

{"answer":"2c","explanation":"strtr with an array replaces longest keys first, so 'ab' is replaced with '2' yielding '2c', and no 'a' remains."}

{"answer": "[]", "explanation": "substr('hello', -10) with a negative start (-10) whose absolute value exceeds the string length (5) returns an empty string in PHP 8+, so the result is []."}

{"answer": "k,n,m", "explanation": "The + operator merges arrays by keeping $a's values for duplicate keys and adding new keys from $b, resulting in keys k, n, m."}

{"answer": "xyz", "explanation": "usort sorts by the third element (index 2), giving order [y,1], [x,2], [z,2]; array_column extracts index 1 values and implode concatenates them to 'xyz'."}

```json ⏎ {"answer": 4, "explanation": "Spreading an associative array uses the keys as named arguments, so $a=5 and $b=1, giving 5-1=4."} ⏎ ```

{"answer": 3, "explanation": "The first-class callable $p->g(...) creates a closure that holds a reference to the object, so setting $p = null does not destroy the object; calling $f() still invokes g() on the living object and returns 3."}

```json ⏎ {"answer": "B", "explanation": "static::class uses late static binding, so it resolves to the class that was actually instantiated, which is B."} ⏎ ```

```json ⏎ {"answer": 10, "explanation": "The set hook multiplies the assigned value by 2 and stores it in the backing store (without re-triggering the hook), so reading $c->x returns 10."} ⏎ ```

{"answer": "BA", "explanation": "TB::f insteadof TA means f() returns 'B', and TA::f as g aliases TA's f() as g() returning 'A', so the concatenation is 'BA'."}

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

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

{"answer": "second", "explanation": "The finally block's throw of LogicException('second') replaces the original RuntimeException and is caught by the outer catch block."}

```json ⏎ {"answer": "App\\Foo|Baz", "explanation": "Baz::class resolves to the aliased App\\Foo via the use statement, while \\Baz::class refers to the global class Baz."} ⏎ ```

{"answer": "noyes", "explanation": "class_exists('Foo') looks in the global namespace (where Foo doesn't exist, it's in Ns), returning 'no'; class_exists('Ns\\Foo') finds the class, returning 'yes'."}

{"answer": "1,2,99", "explanation": "After foreach by reference, $v still references the last element, so assigning 99 to $v modifies $a[2]."}

{"answer": 3, "explanation": "Static variables in a method are shared per class definition, so both instances (A and B inheriting from A) share the same static $n, which increments to 1, 2, then 3."}

```json ⏎ {"answer": "", "explanation": "The generator is still suspended at 'yield 1' after send(10), so getReturn() returns null (the generator hasn't reached the return statement yet), and echoing null produces an empty string."} ⏎ ```

{"answer": "1,2,ok", "explanation": "yield from delegates to inner() yielding 1 and 2, then the expression evaluates to inner()'s return value 'ok', which is stored in $r and yielded, producing [1, 2, 'ok']."}

```json ⏎ {"answer": "noyes", "explanation": "The first call returns false (no rehash needed since cost 4 matches), the second returns true (cost 5 differs from the stored cost 4), so the output is 'no' + 'yes' = 'noyes'."} ⏎ ```

```json ⏎ {"answer": "strict-in", "explanation": "E_STRICT (2048) is deprecated in PHP 8.4 but still included in E_ALL in PHP 8.5, so E_ALL & 2048 is non-zero and the ternary returns 'strict-in'."} ⏎ ```

```json ⏎ {"answer": "mapped", "explanation": "Symfony converts the HTTP_X_TOKEN server variable to the X-Token header, so get('X-Token') returns 'abc'."} ⏎ ```

{"answer": "BCA", "explanation": "Listeners are called in descending priority order: 10 (B), 5 (C), 0 (A)."}

```json ⏎ {"answer": "same", "explanation": "Doctrine ORM's first-level cache (identity map) ensures that find() on the same EntityManager returns the same object instance for an already-known entity ID."} ⏎ ```

```json ⏎ {"answer": 0, "explanation": "Persisting then removing a New (never-flushed) entity before flush causes Doctrine to cancel the scheduled INSERT, so no SQL is emitted and the table remains empty."} ⏎ ```

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

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

{"answer": "M1M2", "explanation": "The middleware stack calls each middleware in order before the next, so M1 echoes first, then M2 echoes before the final handler runs."}

{"answer": 1, "explanation": "Symfony's HandleMessageMiddleware selects only the first compatible handler from the locator, so only $d1's closure runs, incrementing $n by 1."}

{"answer": 1, "explanation": "The first INSERT succeeds, the second is skipped due to ON CONFLICT DO NOTHING on the unique index, so the table contains exactly one row."}

{"answer": 2, "explanation": "The UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, so the uniqueness check is postponed to the end of the transaction, allowing both INSERTs to succeed and the SELECT to return 2."}

```json ⏎ {"answer": 6, "explanation": "The --filter test_sum matches both test_sum and test_sum_abs (substring match), each with 3 data provider entries, giving 3+3=6 tests."} ⏎ ```

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

{"answer": "POST", "explanation": "The -d flag in curl automatically sets the HTTP method to POST."}

{"answer": "GET", "explanation": "The -G flag tells curl to use the HTTP GET method, appending the -d data as a query string to the URL."}

{"answer": "invalid_client", "explanation": "RFC 6749 Section 5.2 defines 'invalid_client' as the error when the client identifier is missing or the client is not authorized, which covers a non-existent client_id."}

{"answer": "fragment", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the authorization server returns the access token in the fragment part of the redirect URI (after the '#' symbol), as specified in RFC 6749 §4.2."}

{"answer": 6, "explanation": "Twig's default filter treats false as empty, so it returns 2, and 2 * 3 = 6."}

```json ⏎ {"answer": 2, "explanation": "In Twig, ~ (concatenation) has higher precedence than +, so 'a' ~ 1 + 2 is parsed as ('a' ~ 1) + 2 = 'a1' + 2, which in PHP evaluates to 2."} ⏎ ```

{"answer": 0, "explanation": "The array [''] is not null or an empty string, so it passes the NotBlank constraint, resulting in 0 violations."}

```json ⏎ {"answer": "valid", "explanation": "An unsubmitted form with no data is considered synchronized and has no validation errors, so isValid() returns true."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "Symfony DI services are singletons by default (shared), so repeated calls to get() return the same object instance."} ⏎ ```

{"answer": "hi Bob!", "explanation": "During compile(), Symfony resolves nested parameter references: %name% becomes 'Bob', %greeting% becomes 'hi Bob', and %greeting%! becomes 'hi Bob!'."}

{"answer": 960, "explanation": "At the lg breakpoint (≥992px), Bootstrap 5.3 sets .container max-width to 960px."}

{"answer": "text-danger", "explanation": "In Bootstrap 5.3, text color utilities are generated in source order (primary, secondary, success, danger, warning, info…), so text-danger appears later in the CSS and wins by cascade order when both have equal specificity."}

```json ⏎ {"answer": 2, "explanation": "The class is in the Domain layer which may only depend on Domain, but it imports from both Application (PlaceOrder) and Infrastructure (Db), resulting in 2 violations."} ⏎ ```

```json ⏎ {"answer": 3, "explanation": "The class is in the Domain layer which may only depend on Domain, but it references Application (PlaceOrder) and Infrastructure (Db, Logger), giving 3 violations."} ⏎ ```

{"answer": "10,15", "explanation": "The add method creates a new Money object with the sum (10+5=15), while the original $a remains unchanged at 10."}

{"answer": 1, "explanation": "The exception is thrown before unset() is called, so the item remains in the array and count() returns 1."}

{"answer": "hi", "explanation": "The method hi() returns the string 'hi', which is echoed to the output."}

{"answer": "yesno", "explanation": "A lazy ghost is uninitialized until first property/method access, so isUninitializedLazyObject returns true before $o->v access and false after the callback fires during that access."}

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

{"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 7.0 (deprecated in 6.4), while AttributeClassLoader is its replacement and exists in 8.1."}