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

{"answer": "no", "explanation": "Double-quoted strings support variable interpolation and more escape sequences (e.g. \\n, \\t), while single-quoted strings do not interpolate variables and only recognize \\\\ and \\'. The difference is not just speed."}

{"answer": "yes", "explanation": "The null coalescing operator (??) is syntactic sugar for isset($var) ? $var : default, so it checks with isset() semantics and produces no warnings or notices for undefined variables or array keys."}

{"answer": "ab", "explanation": "PHP's echo statement accepts multiple comma-separated arguments and concatenates them in output."}

{"answer": "no", "explanation": "While print does evaluate to 1, it is a language construct and cannot be used inside an expression (e.g., $x = print 'hello' is a syntax error)."}

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

{"answer": "yes", "explanation": "In PHP, addition and subtraction have higher precedence than concatenation, so in an expression like 5 + 3 . 2, the addition is evaluated first."}

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

{"answer": 3, "explanation": "Concatenation (.) has higher precedence than addition (+), so it's parsed as ('sum: ' . 2) + 3, which becomes 'sum: 2' + 3; the non-numeric string casts to 0, giving 0 + 3 = 3."}

{"answer": "no", "explanation": "With ===, arrays must have the same key/value pairs in the same order; == is the operator that ignores order."}

{"answer": "no", "explanation": "0 == false actually returns true (not false), and == is a loose comparison, not a strict one; strict comparison is ===."}

{"answer":"no","explanation":"In PHP 8, comparing a non-numeric string to an integer with == converts the integer 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 casts a string to int by reading from the start until a non-numeric character is encountered, so '42abc' becomes 42."}

{"answer": 10, "explanation": "In PHP, the numeric string '5' is cast to an integer when used with the + operator, resulting in 5 + 5 = 10."}

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

{"answer": "yes", "explanation": "Due to IEEE 754 floating-point precision, 0.1 + 0.2 does not exactly equal 0.3, so strict comparison (===) returns false."}

{"answer":"no","explanation":"strrev() reverses a string byte by byte, which breaks multi-byte UTF-8 characters (e.g., accented letters, CJK, emoji) into invalid sequences."}

{"answer": "yes", "explanation": "str_contains() checks if the needle 'world' is found within the haystack 'Hello world', which it is, so it returns true."}

{"answer": "no", "explanation": "str_pad() supports STR_PAD_RIGHT, STR_PAD_LEFT, and STR_PAD_BOTH via its $pad_type parameter."}

{"answer": "no", "explanation": "By default, trim() removes 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 'h', 'l', 'l', 'o' are each 1 byte, giving a total of 6 bytes."}

{"answer": "def", "explanation": "substr with start position -3 extracts the last 3 characters of the string."}

{"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 while nowdoc treats the content as a plain string with no interpolation."}

{"answer": "no", "explanation": "sort() reindexes the array with numeric keys starting from 0, discarding original key associations; use asort() to preserve them."}

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

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

{"answer": "yes", "explanation": "Without a callback, array_filter() removes elements that are falsy: 0, 0.0, '0', '', null, false, and empty arrays."}

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

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

{"answer": 2, "explanation": "The + operator keeps the left array's value for duplicate keys ('a' => 1) and adds new keys from the right ('b' => 2), resulting in a 2-element array."}

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

```json ⏎ {"answer": "no", "explanation": "In PHP 8.0+, named arguments can be combined with argument unpacking as long as the named arguments appear before the unpacking (e.g., foo(a: 1, ...$args) is valid)."} ⏎ ```

{"answer": "no", "explanation": "In PHP, closures do not automatically capture outer scope variables; 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 call, which is 3 (1, 2, 3), regardless of how many parameters are declared."}

{"answer": "no", "explanation": "An arrow function (fn) body consists of a single expression after =>, not multiple expressions in curly braces."}

{"answer":"no","explanation":"PHP arrow functions (fn) automatically capture outer variables by value, not by reference."}

{"answer": "yes", "explanation": "A static closure in PHP is not bound to the current object scope, so it has no access to $this."}

{"answer": 5, "explanation": "The closure captures $x by value (5) at creation time; changing the outer $x to 7 afterward does not affect the captured copy."}

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

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

{"answer": "final", "explanation": "In PHP, the 'final' keyword before a method declaration prevents that method from being overridden in any subclass."}

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

{"answer": "no", "explanation": "Private properties in PHP are only accessible within the class that defines them, not in subclasses; only public and protected properties are accessible in subclasses."}

{"answer": "class@anonymous", "explanation": "Anonymous classes in PHP get a generated name in the format class@anonymous/path/to/file.php:line\\0suffix, so the part before the NUL byte without the file path is 'class@anonymous'."}

{"answer": "yes", "explanation": "In PHP, private methods are not inherited and are invisible to child classes, so a child is free to declare a method with the same name and any visibility level without conflict."}

{"answer": "no", "explanation": "__get() is called for inaccessible properties, which includes both non-existent properties AND properties declared as private or protected."}

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP throws an Error (not an Exception)."}

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

{"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 does not allow interfaces to declare static methods; attempting to do so 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 a class or implements an interface."}

{"answer": "no", "explanation": "In PHP, interface methods are always abstract and cannot have a body/implementation, unlike trait methods which can provide concrete implementations."}

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

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

{"answer": "yes", "explanation": "PHP traits can declare constants, methods, and properties (with some restrictions)."}

{"answer": "yes", "explanation": "In PHP 7+, 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 under Throwable, so catching Exception will not catch TypeError."}

{"answer": "no", "explanation": "The @ operator only suppresses errors (warnings, notices, etc.) via the error reporting mechanism; it does not catch or suppress exceptions."}

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError exception because integer division by zero is undefined."}

{"answer": "no", "explanation": "The finally block executes regardless of whether an exception was thrown or caught; it always runs."}

{"answer": "no", "explanation": "An exception thrown in a finally block replaces (overrides) any exception being propagated from the try block."}

{"answer": "yes", "explanation": "In PHP, casting any object to bool always returns true, as objects are truthy values."}

{"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 does not load the class file; the file is loaded by the autoloader only when the class is actually used at runtime."}

{"answer": "function", "explanation": "In PHP, the 'use' statement imports a function using the 'function' keyword (e.g., use ns\\function foo); 'const' is used for importing constants."}

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

{"answer": "yes", "explanation": "Composer's vendor/autoload.php instantiates a ClassLoader and calls register(), which internally uses spl_autoload_register() to add the autoloader to the stack."}

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

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

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

{"answer": "no", "explanation": "In PHP, namespace 'use' import statements are only allowed at the top level of a file (or within a namespace block), not inside a function body."}

{"answer": "yes", "explanation": "In PHP, arrays are value types and are copied on assignment by default (using copy-on-write internally), not passed by reference unless explicitly using the & operator."}

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

{"answer": "yes", "explanation": "In PHP, user-defined global variables are not in scope inside functions; they must be accessed via the global keyword, $GLOBALS, or passed as parameters."}

{"answer": "no", "explanation": "$GLOBALS contains references to global variables, so unset($GLOBALS['x']) removes the global variable entirely, not just within the current function scope."}

{"answer": 6, "explanation": "The parameter is passed by reference, so the increment inside the function modifies $n directly, changing it from 5 to 6."}

{"answer": "no", "explanation": "A foreach by value iterates over a copy of the array, so modifications to the original array inside the loop are not reflected in the current iteration."}

{"answer": "no", "explanation": "A static property belongs to the class, not to individual instances, so all objects share the same value and changes are visible across all instances."}

{"answer": "no", "explanation": "In PHP, boolean keys in arrays are cast to integers: true becomes 1 and false becomes 0, so they are stored as int, not bool."}

```json ⏎ {"answer": "yes", "explanation": "Since PHP 8.2, a generator's return value can be retrieved via the Generator::getReturn() method."} ⏎ ```

{"answer": "no", "explanation": "PHP generators are one-shot iterators; once fully consumed, calling rewind() on them throws a RuntimeException ('Generator already executed') and they cannot be traversed again."}

{"answer": "yes", "explanation": "yield from is a Python construct that delegates iteration to another iterable or generator, forwarding all its yielded values."}

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

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

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

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

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

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

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

{"answer": true, "explanation": "password_verify() returns true when the plaintext matches the hash generated by password_hash()."}

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags and has nothing to do with SQL injection; protecting against SQL injection requires parameterized queries or proper escaping."}

{"answer": "yes", "explanation": "session_regenerate_id() generates a new session ID, invalidating any previously known ID, which is the standard defense against session fixation attacks typically called upon user login."}

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

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

{"answer": "no", "explanation": "The $_SESSION array is only populated with session data after session_start() is explicitly called; without it, $_SESSION is either undefined or empty."}

{"answer": 8.4, "explanation": "The array_find() function was introduced in PHP 8.4 as part of the 'Add array_find and array_find_key' RFC."}

{"answer": "yes", "explanation": "PHP 8.4 introduced property hooks, allowing get and set logic to be declared directly in the property definition."}

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

{"answer": "not introduced", "explanation": "The #[\\NoDiscard] attribute does not exist in any released PHP version."}

{"answer": "8.4", "explanation": "The pipe operator |> was introduced in PHP 8.4."}

{"answer": "no", "explanation": "No such 'clone-with' syntax exists in any released PHP version."}

{"answer": "not introduced", "explanation": "array_first() and array_last() are not built-in PHP functions in any released version."}

{"answer": "I don't know", "explanation": "I am not aware of an RFC called 'Partial Function Application v2' being adopted into any PHP version as of my knowledge cutoff."}

{"answer": "8.4", "explanation": "The clamp_v2 RFC was accepted and implemented in PHP 8.4."}

{"answer": "no", "explanation": "There is no known 'Context Managers v2' RFC that has been adopted in PHP."}

```json ⏎ {"answer": "yes", "explanation": "The Bound-Erased Generic Types (generics) RFC was voted on by the PHP internals group and was declined."} ⏎ ```

{"answer": "no", "explanation": "No RFC making ZTS (Zend Thread Safety) the default build has been accepted in PHP; the default remains NTS."}

{"answer": "yes", "explanation": "PHP has never included built-in generics (parameterized types), and none are planned for PHP 8.5."}

{"answer": "yes", "explanation": "PHP releases a new minor version each November; PHP 8.5 was released in November 2025, so as of November 7, 2026, it is the latest stable, with PHP 8.6 scheduled for November 19, 2026."}

{"answer": "yes", "explanation": "PHP 6 was a planned major version that was abandoned; its work was folded into PHP 7.0, which released directly after PHP 5.6."}

{"answer": "no", "explanation": "The RFC to add a built-in #[\\Deprecated] attribute to PHP core was rejected and not adopted."}

{"answer": "yes", "explanation": "In both Clean and Onion architecture, dependencies must point inward toward the center; inner layers are unaware of and do not depend on outer layers."}

{"answer": "yes", "explanation": "Domain entities should be pure PHP classes free of framework and ORM dependencies, relying only on the language and possibly the standard library (SPL)."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (interface) layer; the business-logic layer contains the use cases and domain entities themselves."}

{"answer": "Entity", "explanation": "In the onion architecture, the Entity (core domain business logic) sits at the very center, with layers of application services, adapters, and infrastructure wrapping around it."}

{"answer": "yes", "explanation": "Deptrac and similar tools define 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 (e.g., repository interfaces), not on concrete framework/infrastructure objects like an HTTP request or an EntityManager, to remain decoupled and testable."}

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

{"answer": "yes", "explanation": "In clean architecture, the domain and use cases depend only on abstractions (e.g., repository interfaces), so changing the database driver affects only the outermost infrastructure layer."}

{"answer": "no", "explanation": "An aggregate is a domain-level cluster of entities and value objects treated as a unit of consistency, not a database table — it can span multiple tables or share tables with other aggregates."}

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

{"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the Aggregate Root is the single entry point of an aggregate, and all external changes must go through it to maintain invariants."}

{"answer": "yes", "explanation": "In DDD, a Repository is defined per Aggregate (root), ensuring encapsulation and invariant enforcement within the aggregate boundary."}

{"answer": "yes", "explanation": "In Domain-Driven Design, the Ubiquitous Language is the shared vocabulary used consistently by both developers and domain experts in code, documentation, and conversation."}

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

{"answer": "no", "explanation": "DDD advocates for a rich domain model where business logic lives inside entities and aggregates, not in external services; anemic models are considered an anti-pattern in DDD."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a Bounded Context ensures that each context maintains its own model, so the same real-world concept (e.g., 'Product') is represented as a distinct class with its own meaning in each context."}

{"answer": "yes", "explanation": "Symfony's DI container instantiates services only when they are first requested via get(), not eagerly at boot time."}

{"answer": "debug:router", "explanation": "The Symfony console command to list all registered routes is 'bin/console debug:router'."}

{"answer": "no", "explanation": "Autowiring in Symfony automatically resolves dependencies based on type hints, so services do not need to be manually declared in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes (extending Twig\\Template) and caches the compiled output 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 (config, classes, etc.) have changed, not on every request."}

{"answer": "APP_ENV", "explanation": "The APP_ENV environment variable is used by Symfony to select the active environment (e.g., dev, prod, test)."}

{"answer": "no", "explanation": "Symfony controller methods must be public; private or protected methods cannot be used as route targets."}

{"answer": "no", "explanation": "Event subscribers and listeners are dispatched based on their assigned priority (or registration order if equal); subscribers have no inherent priority over listeners."}

{"answer": "yes", "explanation": "The old guard system was deprecated in Symfony 5.3 and fully removed in Symfony 6.0, leaving AuthenticatorInterface as the sole authentication mechanism."}

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

{"answer": "yes", "explanation": "Voters in Symfony are the mechanism for object-level access control, used with isGranted() to check permissions on specific objects like $post."}

{"answer": "yes", "explanation": "Symfony 7 removed support for doctrine/annotations, so validation constraints must now be declared using native PHP 8 attributes like #[Assert\\NotBlank]."}

{"answer": "yes", "explanation": "Symfony forms include a CSRF token by default and validate it on submission unless explicitly disabled via framework config."}

{"answer": "yes", "explanation": "Symfony always performs server-side validation using its Validation component; HTML5 client-side checks are merely a UX convenience and can be bypassed."}

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

{"answer": "no", "explanation": "Symfony never stores passwords in plain text in the session; passwords are hashed (e.g., with bcrypt or Argon2) and stored in the database, while the session only holds the user identifier and authentication token."}

{"answer": "yes", "explanation": "In modern Symfony, bundle configurations 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 pattern (e.g., in Symfony) where .env holds safe dev defaults committed to git, while .env.local holds real secrets and is gitignored."}

{"answer": "debug:container", "explanation": "The Symfony console command `debug:container` lists all registered services and their aliases in the dependency injection container."}

{"answer": "no", "explanation": "At runtime the container is compiled and immutable; setParameter() is only available on the ContainerBuilder during the build phase, not on the runtime Container instance."}

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

{"answer": "no", "explanation": "Many bundles in Symfony work perfectly fine without a configuration file in config/packages, as they provide sensible defaults and configuration is not mandatory for every bundle."}

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

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable controls Symfony's debug mode, enabling the profiler and Twig debug features."}

{"answer": "no", "explanation": "Symfony Messenger allows multiple handlers to be registered for the same message class, and all of them will be called in order."}

{"answer": "no", "explanation": "The sync transport handles the message immediately in the same process without queuing it for a worker."}

{"answer": "messenger:consume", "explanation": "The Symfony Messenger command to start a worker that processes queued messages is messenger:consume."}

{"answer": "no", "explanation": "The retry_strategy is configured at the message bus level (under messenger.buses), not per transport."}

{"answer": "yes", "explanation": "Symfony Messenger's default serializer is JsonSerializer, which serializes messages to JSON by default."}

{"answer": "yes", "explanation": "Symfony Scheduler schedules tasks (including message objects) and dispatches them through the Messenger component when their time comes."}

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

{"answer": "yes", "explanation": "The Messenger pipeline (e.g., in Laravel) is extensible and allows adding custom middleware at any position, before or after built-in ones."}

{"answer": "yes", "explanation": "Symfony releases minor versions every six months (May and November) and major versions every two years (November)."}

{"answer": "8.4", "explanation": "Symfony 8 requires a minimum PHP version of 8.4, following Symfony's pattern of requiring the two most recent PHP stable versions at release time."}

{"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations; PHP 8 attributes are the only supported way to define validation rules, routes, etc."}

{"answer": "yes", "explanation": "Symfony's AssetMapper component manages CSS/JS assets without Node.js or Webpack, using an importmap.php file to define asset imports."}

{"answer": "no", "explanation": "Symfony 6.4 is a Long-Term Support (LTS) release, with bug fixes until November 2025 and security fixes until November 2027."}

{"answer": "no", "explanation": "In Symfony, deprecated features are removed in the next major version; that is the entire purpose of the deprecation cycle."}

{"answer": "yes", "explanation": "Each Symfony major release includes an UPGRADE-X.Y file in the repository documenting breaking changes, removed deprecations, and other migrations."}

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

```json ⏎ {"answer": "no", "explanation": "Symfony 8.2 is a November 2026 release (8.0 in Nov 2025, 8.1 in May 2026, 8.2 in Nov 2026), so it would not have been released yet as of November 7, 2026."} ⏎ ```

{"answer": "yes", "explanation": "Symfony releases minor versions every six months (May and November), so 8.0 (Nov 2025), 8.1 (May 2026), and 8.2 (Nov 2026) follows the standard cycle."}

{"answer": "8.2", "explanation": "Symfony releases minor versions every 6 months, so 8.2 follows 8.1."}

{"answer": "no", "explanation": "Symfony 8.2 would be a minor release (not major), and Symfony's major releases follow a deprecation policy rather than requiring full rewrites."}

{"answer": "no", "explanation": "In PHP, each x.y release (e.g., 8.1 → 8.2) is considered a major release, and backward compatibility is NOT guaranteed; deprecated features can be removed and new deprecations are introduced between these versions."}

```json ⏎ {"answer": "8.4", "explanation": "Symfony follows a pattern where each major branch ends at .4 (the LTS version), so the last 8.x release before 9.0 is 8.4."} ⏎ ```

{"answer": "no", "explanation": "Symfony 8.x is expected to require PHP 8.4 as its minimum, not PHP 8.5."}

{"answer": "yes", "explanation": "Symfony's policy is that deprecations introduced in a major version (8.x) are removed in the next major version (9.0), so they will not be removed before 9.0."}

{"answer": "no", "explanation": "Twig's {{ }} syntax only supports Twig's own expressions (variables, filters, functions, operators), not arbitrary PHP code."}

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

{"answer": "yes", "explanation": "The |e filter in Twig applies HTML escaping (equivalent to htmlspecialchars with ENT_QUOTES) by default to prevent XSS attacks."}

{"answer": "localizednumber", "explanation": "The twig/intl-extra package provides the localizednumber filter which formats a number according to a given locale."}

{"answer": "yes", "explanation": "The |raw filter (used in Twig and similar templating engines) marks a value as safe, bypassing automatic HTML escaping."}

{"answer": "yes", "explanation": "In Twig, double curly braces {{ }} output the result of an expression, while percent braces {% %} execute control-structure tags like if, for, set, etc."}

{"answer": "no", "explanation": "Twig allows you to set 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 (array, object, etc.), typically using var_dump under the hood."}

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

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

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

{"answer": "yes", "explanation": "Bootstrap 5 defines exactly five named breakpoints (sm, md, lg, xl, xxl) that can be used as infixes in utility and grid class names."}

{"answer": "no", "explanation": "The spacing scale is not a direct linear multiple of $spacer; for example, .mt-1 equals $spacer * 0.25 and .mt-3 equals $spacer * 1, so the number does not correspond to a simple multiple."}

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

{"answer": "yes", "explanation": "Bootstrap 5 dropped its jQuery dependency and uses vanilla JavaScript for all its interactive components."}

{"answer": "no", "explanation": "Bootstrap 5 enables dark mode via the data-bs-theme=\"dark\" attribute on the <html> element, not a .dark class."}

{"answer": "no", "explanation": "Doctrine ORM does not auto-create tables; you must explicitly run schema commands or migrations to create/update database tables."}

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

{"answer": "no", "explanation": "EntityManager::merge() returns a managed *copy* of the passed entity; the original detached object itself is not made managed."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is an object-oriented query language that operates on entity names and their properties, abstracting away the underlying table and column structure."}

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

{"answer": "no", "explanation": "DoctrineBundle does not automatically call flush(); it only commits or rolls back the transaction at the end of the request, so the developer must explicitly call flush() to persist changes."}

{"answer": "yes", "explanation": "The Unit of Work tracks managed entities and detects property changes on flush(), so no explicit persist() is needed for already-managed entities."}

{"answer": "no", "explanation": "remove() only schedules the entity for deletion in the UnitOfWork; the actual SQL DELETE 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; that's the entire purpose 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 syntactic sugar that creates a separate sequence object and sets it as the column's default, while GENERATED ... AS IDENTITY is a SQL-standard built-in identity column mechanism with different internal behavior (e.g., tied to the column, supports GENERATED ALWAYS/BY DEFAULT, and cannot be independently dropped as a standalone object)."}

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

{"answer": "string_agg", "explanation": "PostgreSQL's string_agg(expression, delimiter) aggregate function concatenates string values with a specified separator."}

{"answer": "no", "explanation": "Plain VACUUM reclaims space for internal reuse by the database but does not return it to the operating system; VACUUM FULL is needed for that."}

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

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

{"answer": "yes", "explanation": "By default, PostgreSQL operates in autocommit mode, where each SQL statement is automatically committed upon completion, effectively wrapping each statement in its own implicit transaction."}

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

{"answer": "yes", "explanation": "Indexes help the database engine locate rows quickly, which benefits SELECT, UPDATE, and DELETE queries that filter on indexed columns."}

{"answer": "yes", "explanation": "SAVEPOINT in PostgreSQL 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 reports real execution times and row counts; plain EXPLAIN shows the plan without executing."}

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

{"answer": "yes", "explanation": "A partial index (CREATE INDEX ... WHERE ...) only includes rows that satisfy the specified condition, reducing index size and improving query performance for targeted lookups."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which detects and aborts conflicting transactions via dependency tracking, not by locking read rows."}

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

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

```json ⏎ {"answer": "yes", "explanation": "RFC 9110 (HTTP Semantics) classifies DELETE as an idempotent method: repeating the request for the same resource does not produce a different outcome than the first request."} ⏎ ```

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

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests is specifically defined in RFC 6585 to indicate that a client has exceeded the allowed rate limit."}

{"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 explicitly states that PATCH is not idempotent, while PUT is defined as idempotent in RFC 7231."}

```json ⏎ {"answer": "no", "explanation": "Using == is vulnerable to timing attacks; you should use hash_equals() or password_verify() for constant-time comparison."} ⏎ ```

{"answer": "yes", "explanation": "CSRF tokens are server-issued, session-bound, and verified server-side on state-changing requests like POST."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to specify which resources are allowed to load and execute on the page."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol, not an authentication protocol; the access token grants permission to access resources but does not identify who the user is."}

{"answer": "no", "explanation": "XSS is prevented by output encoding (context-aware encoding) at the point of output, not by input validation or sanitization before storing in the database."}

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

{"answer": "yes", "explanation": "A refresh token is designed to have a longer lifespan than an access token and is used to obtain a new access token without requiring the user to authenticate again."}

{"answer": "no", "explanation": "A salt is not secret; it is typically stored alongside the hash. Its purpose is to prevent rainbow table attacks by ensuring identical passwords produce different hashes, not to add secrecy."}

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

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

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

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

{"answer": "no", "explanation": "The definitions are reversed: a stub returns pre-programmed data, while a mock verifies that expected method calls were made."}

{"answer": "yes", "explanation": "PHPUnit 10 introduced PHP attributes as the replacement for docblock annotations, making #[DataProvider] the recommended way over the deprecated @dataProvider annotation."}

{"answer": "no", "explanation": "PHPUnit does allow test dependencies via the @depends annotation or the depends() method, which passes the result of one test as a parameter to another."}

{"answer": "--random-order", "explanation": "The --random-order option in PHPUnit causes tests to be executed in a random order."}

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

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

```json ⏎ {"answer": "false", "explanation": "In PHP 8+, comparing two strings with == performs a string comparison, and '1e1' !== '10' as strings."} ⏎ ```

```json ⏎ {"answer": "other", "explanation": "In PHP 8, the loose comparison 'a' == 0 is false (non-numeric string vs integer 0), so the switch falls through to the default case."} ⏎ ```

{"answer": "2c", "explanation": "strtr with an array replaces the longest matching key first, so 'ab' is replaced by '2' before 'a' is considered, yielding '2c'."}

{"answer": "[]", "explanation": "substr('hello', -10) returns an empty string because -10 is beyond the start of the 5-character string, so the result is just the brackets with nothing inside."}

{"answer": "k,n,m", "explanation": "The union operator (+) keeps left array's values for duplicate keys and appends right array's new keys, resulting in keys ['k','n','m']."}

```json ⏎ {"answer": "yxz", "explanation": "The array is sorted by the third element (1, 2, 2), then column index 1 is extracted and concatenated: 'y' + 'x' + 'z' = 'yxz'."} ⏎ ```

{"answer": 4, "explanation": "The spread operator with string keys assigns values by parameter name, so $a=5 and $b=1, giving 5-1=4."}

```json ⏎ {"answer": 3, "explanation": "The callable $f holds a reference to object $p, so even after $p is set to null, the object is still alive and g() returns the private property value 3."} ⏎ ```

{"answer": "B", "explanation": "static::class uses late static binding and returns the class of the object instance (B), not the class where the method is defined (A)."}

```json ⏎ {"answer": 10, "explanation": "The set hook is invoked with $value=5, stores 5*2=10 in the backing store (assignments within the hook don't re-trigger it), so echo outputs 10."} ⏎ ```

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

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

```json ⏎ {"answer": 2, "explanation": "A return statement in a finally block overrides any return in the try block, so the function returns 2."} ⏎ ```

{"answer": "second", "explanation": "The finally block throws a LogicException which replaces the original RuntimeException, and the outer catch catches the LogicException and prints its message 'second'."}

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

{"answer": "noyes", "explanation": "class_exists('Foo') checks the global namespace (false → 'no'), while class_exists('Ns\\Foo') checks the correct namespace (true → 'yes')."}

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

{"answer": 3, "explanation": "Static variables are shared across all instances of the class (and subclasses that don't override the method), so $n is incremented three times total, and the last call returns 3."}

```json ⏎ {"answer": 11, "explanation": "send(10) assigns 10 to $x (the result of yield 1), then return $x + 1 returns 11, which getReturn() outputs."} ⏎ ```

{"answer":"1,2,ok","explanation":"yield from delegates to inner() yielding 1 and 2, captures the return value 'ok' into $r, then yields it, giving [1, 2, 'ok'] which implode joins to '1,2,ok'."}

{"answer": "noyes", "explanation": "The first call returns false because the hash already uses cost 4, and the second returns true because cost 5 differs from the hash's cost of 4."}

{"answer": "strict-out", "explanation": "In PHP 8.5, E_STRICT (2048) is no longer included in E_ALL, so the bitwise AND yields 0."}

```json ⏎ {"answer": "mapped", "explanation": "Symfony's HeaderBag strips the HTTP_ prefix and normalizes underscores to dashes, so HTTP_X_TOKEN becomes X-TOKEN, and get() is case-insensitive, so 'X-Token' resolves to the stored value 'abc'."} ⏎ ```

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

{"answer": "same", "explanation": "Doctrine ORM's identity map ensures that find() returns the same object instance for an already-managed entity, so both $a and $b are the identical PHP object."}

{"answer": 0, "explanation": "When an entity is persisted and then removed before flush, the UnitOfWork cancels the pending INSERT entirely, so no row is ever written to the database."}

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

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

```json ⏎ {"answer": "M1M2", "explanation": "The middleware stack executes in order: M1 echoes 'M1' and delegates to M2, which echoes 'M2' and delegates to the terminal handler; the output is the concatenation of both tags."} ⏎ ```

```json ⏎ {"answer": 11, "explanation": "Both handlers are called sequentially: $n increments by 1 then by 10, resulting in 11."} ⏎ ```

{"answer": 1, "explanation": "The first INSERT adds a row, the second INSERT hits the unique index conflict and does nothing, so count(*) returns 1."}

{"answer": 2, "explanation": "The UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, so uniqueness is only checked at COMMIT time, allowing both duplicate inserts to succeed within the transaction."}

```json ⏎ {"answer": 6, "explanation": "The --filter test_sum regex matches both test_sum (3 data set entries) and test_sum_abs (3 data set entries), totaling 6 tests."} ⏎ ```

{"answer":"2,1","explanation":"The data provider supplies two datasets ([1] and [-1]); test_x(1) passes (1>0 is true) and test_x(-1) fails (-1>0 is false)."}

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

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

{"answer": "invalid_client", "explanation": "RFC 6749 Section 5.2 defines 'invalid_client' as the error returned when the client does not exist or cannot be authenticated."}

{"answer": "fragment", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access token is returned in the URI fragment (after #) of the redirect_uri, not in the query string."}

```json ⏎ {"answer": 0, "explanation": "The default filter only triggers on null/undefined values, so false passes through unchanged, and false * 3 evaluates to 0 in PHP."} ⏎ ```

{"answer": "a3", "explanation": "In Twig, the + operator has higher precedence than ~, so it parses as 'a' ~ (1+2) = 'a' ~ 3 = 'a3'."}

{"answer": 0, "explanation": "The array [''] has count 1, so it is not blank; the NotBlank constraint passes, resulting in 0 violations."}

```json ⏎ {"answer": "invalid", "explanation": "A TextType form defaults to required=true, so an unsubmitted (empty) form has a validation error, making isValid() return false."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "Symfony's DI container caches service instances after compilation, so repeated get() calls return the same object."} ⏎ ```

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

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

```json ⏎ {"answer": "text-danger", "explanation": "Both classes have the same specificity, so the one appearing later in the compiled Bootstrap CSS wins; .text-danger is defined after .text-primary in the utility order."} ⏎ ```

{"answer": 2, "explanation": "The class is in the Domain layer, which may only depend on Domain; using Application\\PlaceOrder and Infrastructure\\Db are both violations."}

```json ⏎ {"answer": 3, "explanation": "The Domain-layer class BillingService depends on Application (PlaceOrder) and Infrastructure (Db, Logger), which are all three violations since Domain may only depend on Domain."} ⏎ ```

{"answer": "10,15", "explanation": "$a has amount 10, and $c is a new Money object with 10+5=15, so the output is '10,15'."}

{"answer": 1, "explanation": "The remove() method throws DomainException before unset() is reached because count is 1, so the item is never removed and count() still returns 1."}

{"answer": "hi", "explanation": "The code instantiates class C and calls hi() which returns the string 'hi', which is then echoed."}

{"answer": "yesno", "explanation": "Before property access the lazy ghost is uninitialized (yes), and after accessing $o->v the callback runs and the object becomes initialized (no)."}

```json ⏎ {"answer": "no", "explanation": "The Guard authentication system, 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 (replaced by AttributeClassLoader), so on 8.1 it no longer exists (no), while AttributeClassLoader does exist (yes), concatenating to 'noyes'."}