Карта знаний PHP — huihui-ai:pi-100k, run-81 · think: low

```json ⏎ {"answer": "no", "explanation": "Double-quoted strings support variable interpolation and more escape sequences, while single-quoted strings do not — the difference is not just speed but functionality."} ⏎ ```

{"answer": "yes", "explanation": "The ?? operator is equivalent to isset($var) ? $var : default, so it suppresses notices/warnings for undefined variables."}

{"answer": "ab", "explanation": "The echo statement accepts multiple arguments separated by commas and outputs them sequentially without any separator."}

{"answer": "yes", "explanation": "In PHP, print always returns the integer 1, so it can be used inside expressions, unlike echo which returns no value."}

{"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": "no", "explanation": "In PHP, the concatenation operator (.) has the same precedence as addition (+) and subtraction (-), not lower."}

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

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

{"answer": "no", "explanation": "With strict comparison (===), arrays are only considered equal if they have the same key/value pairs in the same order and of the same type; order matters."}

{"answer": "no", "explanation": "0 == false uses a loose comparison (==), and it actually returns true because false is cast to 0."}

{"answer": "no", "explanation": "In PHP 8, when a non-numeric string is loosely compared to 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 the leading numeric portion of a string, so '42abc' becomes 42."}

{"answer": 10, "explanation": "PHP coerces the numeric string '5' to integer 5, then performs arithmetic addition: 5 + 5 = 10."}

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

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

{"answer":"no","explanation":"strrev() operates on a byte-by-byte basis, which will corrupt multi-byte UTF-8 characters rather than reversing them as whole code points."}

{"answer": "yes", "explanation": "str_contains() returns true when the haystack contains the needle, and 'Hello world' does contain 'world'."}

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

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

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

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

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

{"answer": "yes", "explanation": "Heredoc allows variable interpolation just like double-quoted strings, while nowdoc treats content as a plain string (like single-quoted strings) where variables are not interpolated."}

{"answer": "no", "explanation": "sort() reindexes the array with integer keys; use asort() to preserve key-value associations."}

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

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

{"answer": "yes", "explanation": "Without a callback, array_filter() removes all elements that evaluate to falsy (false, 0, '0', '', null, [])."}

{"answer": "no", "explanation": "The $preserve_keys parameter defaults to false, so array_slice() reindexes the array with sequential numeric keys starting from 0 by default."}

{"answer": [20, 30], "explanation": "array_slice with offset 1 and length 2 returns the 2 elements starting at index 1, which are 20 and 30."}

{"answer": 2, "explanation": "Array union with + keeps left-hand keys and appends right-hand keys not present in the left, resulting in ['a'=>1, 'b'=>2'] which has 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 introduced the spread operator in array literals, which supports both integer and string keys, with later values overwriting earlier ones on key collision."}

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

{"answer": "no", "explanation": "In PHP, anonymous functions (closures) do not have access to outer scope variables unless they are explicitly imported using the `use` keyword."}

{"answer": 3, "explanation": "func_num_args() returns the number of arguments actually passed to the function, which is 3 in this case, even though only one parameter is declared."}

{"answer": "no", "explanation": "An arrow function (fn) body must be a single expression; for multiple statements you need a regular closure with curly braces."}

{"answer":"no","explanation":"Arrow functions (fn) capture outer variables by value (eagerly at creation time), not by reference."}

{"answer": "yes", "explanation": "In PHP, a static closure explicitly does not bind $this to the current object scope."}

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

{"answer": "yes", "explanation": "In PHP's weak typing mode (default), the string '5' is automatically coerced to the integer 5 when passed to an int-typed parameter."}

{"answer": "yes", "explanation": "Constructor property promotion was introduced in PHP 8.0, allowing visibility modifiers on constructor parameters to automatically create class properties."}

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

{"answer": "yes", "explanation": "In PHP, a method declared as final cannot be overridden by a subclass; attempting to do so results in a fatal error."}

{"answer": "no", "explanation": "In PHP, private properties are only accessible within the class that declares them; they are not accessible in a subclass."}

```json ⏎ {"answer": "class@anonymous", "explanation": "In PHP, anonymous classes are internally named 'class@anonymous' followed by a NUL byte and the file path/line number; get_class() returns the full name but the part before the NUL byte is 'class@anonymous'."} ⏎ ```

{"answer":"yes","explanation":"Private methods are not inherited in PHP, so a child class can freely declare a method with the same name and any visibility without conflict."}

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

{"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 accessible via the interface name."}

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

{"answer": "yes", "explanation": "PHP interfaces can declare static method signatures that implementing classes must fulfill."}

{"answer": "no", "explanation": "The instanceof operator in PHP checks both class inheritance and interface implementation; an object will return true for instanceof against any interface its class implements."}

{"answer": "no", "explanation": "In PHP, interface methods are always abstract and cannot have a default implementation; only trait methods can be concrete with a body."}

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared with public or protected visibility (abstract private is also syntactically allowed but discouraged)."}

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

{"answer": "yes", "explanation": "Since PHP 8.2, traits can declare constants (as well as properties)."}

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

{"answer": "no", "explanation": "TypeError extends Error, not Exception; both implement Throwable but are separate branches, so catch(Exception) does not catch TypeError."}

{"answer": "no", "explanation": "The @ operator suppresses errors (warnings, notices, etc.) but does not suppress exceptions; exceptions will still propagate normally."}

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError, which extends ArithmeticError, when the divisor is zero."}

{"answer": "no", "explanation": "The finally block runs regardless of whether an exception was thrown or caught — it always executes after the try block (and any matching catch block) completes."}

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

{"answer": "yes", "explanation": "In PHP, casting any object to bool always results in true, since objects are never falsy."}

{"answer": "yes", "explanation": "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 only creates an alias for the class; the class file is actually loaded (via autoloading) only when the class is first used, such as during instantiation or a static call."}

{"answer": "function", "explanation": "In PHP, you use 'use function' to import a function from a namespace."}

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

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

{"answer": "yes", "explanation": "__NAMESPACE__ is a 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 'new' is first resolved relative to the current namespace, not the global root; it only falls back to global if not found in the current namespace."}

{"answer": "yes", "explanation": "PSR-4 maps the App\\ prefix to src/, and the remaining sub-namespace Model\\User translates to the relative path Model/User.php, giving src/Model/User.php."}

{"answer": "yes", "explanation": "In PHP, a use statement can be placed inside a function body, and the alias it creates is only valid within that function's scope."}

{"answer": "yes", "explanation": "In PHP, arrays are value types; assigning an array to a new variable creates a copy, so modifications to one do not affect the other."}

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

{"answer": "yes", "explanation": "In PHP, function scope is isolated from global scope, so global variables must be explicitly brought into scope via global, $GLOBALS, or passed as parameters."}

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

{"answer": 6, "explanation": "The function modifies $n by reference, incrementing it from 5 to 6."}

{"answer": "no", "explanation": "In PHP, foreach by value iterates over a snapshot (copy-on-write) of the array, so modifications made to the array inside the loop body are not reflected in the ongoing iteration."}

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

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

{"answer": "yes", "explanation": "Since PHP 7.0, you can use a return statement with a value inside a generator, and retrieve it via the Generator object's getReturn() method after the generator is complete."}

{"answer": "no", "explanation": "A PHP generator's rewind() is a no-op; once fully consumed, you must call the generator function again to get a fresh iterator."}

{"answer": "yes", "explanation": "In PHP 7.0+, `yield from` delegates traversal to another generator or iterable, flattening nested iteration."}

{"answer": "Generator", "explanation": "Calling a generator function (one containing yield) returns a Generator object, so get_class() on it returns 'Generator'."}

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

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

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

{"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 into the returned hash string; no separate salt parameter is needed."}

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

{"answer": "yes", "explanation": "password_verify() returns true when the plain-text password matches the hash, which it does here since both use 'secret'."}

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags from a string; SQL injection is prevented by prepared statements or parameterized queries, not by stripping tags."}

{"answer": "yes", "explanation": "session_regenerate_id() generates a new session ID while preserving session data, which is the standard defense against session fixation attacks after a user's authentication state changes."}

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

{"answer": "yes", "explanation": "session_destroy() only removes the session data on the server; the session cookie in the browser persists unless explicitly deleted with setcookie() using a past expiration time."}

{"answer": "no", "explanation": "The $_SESSION array is only populated with session data after session_start() is called, which initializes the session and loads stored data into $_SESSION."}

{"answer": 8.1, "explanation": "The array_find() function was introduced in PHP 8.1 as part of the higher-order array functions."}

{"answer": "yes", "explanation": "Property hooks (get/set defined inline on a property declaration) were indeed introduced in PHP 8.4."}

{"answer": "yes", "explanation": "Asymmetric visibility (e.g. public private(set) string $name) is a feature introduced in PHP 8.4, allowing different read and write visibility levels for properties."}

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

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

```json ⏎ {"answer": "8.4", "explanation": "The clone-with syntax (clone($obj, ['x' => 1]) was introduced in PHP 8.4."} ⏎ ```

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

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

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

```json ⏎ {"answer": "no", "explanation": "As of late 2026, the Context Managers v2 RFC had not yet been fully adopted into PHP; it was still in the proposal or voting stage."} ⏎ ```

{"answer": "no", "explanation": "The Generic Types (Bound-Erased Generic Types) RFC was accepted in 2024 for PHP 8.4, not declined in 2026."}

{"answer": "yes", "explanation": "An RFC to make the Zend Thread Safe (ZTS) build the default in PHP was accepted as part of the PHP 9.0 development cycle, ahead of the 2026-11-07 date."}

{"answer": "yes", "explanation": "Despite long-standing discussions and RFCs, PHP has not shipped generics (parameterized types) as of PHP 8.5."}

{"answer": "yes", "explanation": "PHP follows a yearly release cycle in mid-to-late November, so as of 2026-11-07 the latest stable would be 8.5 (released Nov 2025), with 8.6 scheduled for GA on 2026-11-19."}

{"answer": "yes", "explanation": "PHP 6 was planned but never released; the version numbering went directly from PHP 5.6 to PHP 7.0 in December 2015."}

{"answer": "no", "explanation": "The RFC for the #[\\Deprecated] attribute was voted on for PHP 8.4 but was not adopted (it failed to reach the required two-thirds majority)."}

{"answer": "yes", "explanation": "In clean/onion architecture, the dependency rule mandates that dependencies always point inward (toward the domain core), so inner layers have no knowledge of outer layers."}

{"answer": "yes", "explanation": "In DDD and clean architecture, domain entities should be pure PHP classes with no framework or ORM dependencies, relying only on the language and standard library."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (interface) layer; they call use cases but are not part of the business-logic layer."}

{"answer": "Enterprise Business Rules", "explanation": "In the onion (clean) architecture, the innermost layer contains the enterprise business rules and domain entities, which have no dependencies on any outer layers."}

{"answer": "yes", "explanation": "Deptrac and similar layer-dependency analyzers can be configured with forbidden layer dependencies and will fail the build when a violation is detected, enabling automated detection of layer boundary violations."}

{"answer": "no", "explanation": "A use case (interactor) should accept domain-level data (DTOs, arrays) rather than infrastructure objects like HTTP requests or EntityManagers, to maintain separation of concerns and testability."}

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

{"answer": "yes", "explanation": "In Clean Architecture, the database is an infrastructure concern in the outermost layer; the domain and use cases depend only on abstractions (interfaces/ports), so swapping the database engine requires changes only in the outermost layer."}

{"answer": "no", "explanation": "An aggregate is a cluster of domain objects (entities and value objects) treated as a single unit for consistency, and it can span multiple tables or be part of one table — it is a domain-level concept, not a synonym for a database table."}

{"answer": "yes", "explanation": "By definition in DDD, Value Objects are immutable and use value-based equality rather than reference identity."}

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

{"answer": "yes", "explanation": "In DDD, repositories are declared for aggregate roots only, as they define the consistency boundary; entities within an aggregate are accessed through the root."}

{"answer": "yes", "explanation": "Ubiquitous Language is a Domain-Driven Design concept defined as the shared vocabulary used consistently by both developers and domain experts."}

```json ⏎ {"answer": "frame", "explanation": "A frame is the conceptual boundary within which a model and its language maintain consistent meaning, while outside it the same terms may refer to different models."} ⏎ ```

{"answer": "no", "explanation": "DDD recommends rich domain models where entities and value objects encapsulate business logic, not anemic models with logic in services."}

{"answer": "yes", "explanation": "In DDD, a bounded context has its own model, and the same real-world concept can be represented by different classes with different attributes and behaviors in different contexts."}

{"answer": "yes", "explanation": "Symfony's DI container instantiates services lazily, meaning they are only created when first requested rather than at container build time."}

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

{"answer": "no", "explanation": "Autowiring automatically resolves dependencies via type-hints, so you do not need to manually declare every service or its dependencies in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes that extend \\Twig\\Template and caches them as PHP files for reuse between requests."}

{"answer": "yes", "explanation": "Symfony's dev environment caches the compiled DI container and only rebuilds it when tracked files (config, classes, etc.) have been modified, not on every request."}

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

{"answer": "no", "explanation": "Symfony's controller resolver invokes the method via an array callable from outside the class, so a private method will throw a 'Call to private method' error; the method must be public (or at least protected/visible to the caller)."}

```json ⏎ {"answer": "no", "explanation": "Priority is determined by the numeric priority value assigned to each handler, not by whether it is registered as a subscriber or a listener; the subscriber interface does not grant inherent priority."} ⏎ ```

{"answer": "yes", "explanation": "Symfony 5.3 deprecated the guard system and Symfony 6.0 removed it, replacing it with the new authenticator-based system built on AuthenticatorInterface."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute in Symfony checks if the user has a specified role or permission on a controller method, throwing AccessDeniedException (403) if not."}

{"answer": "yes", "explanation": "Voters in Symfony are the mechanism for object-level security checks, allowing you to use isGranted('EDIT', $post) to check access to a specific object."}

{"answer": "yes", "explanation": "In Symfony 7+, PHP attributes (#[Assert\\NotBlank]) are the standard way to declare validation constraints, while doctrine/annotations is deprecated in favor of native PHP attributes."}

{"answer": "yes", "explanation": "Since Symfony 3.3, CSRF protection is enabled by default for all forms; a hidden token field is added and validated automatically on submission unless explicitly disabled."}

```json ⏎ {"answer": "yes", "explanation": "Symfony always performs server-side form validation on submission; client-side HTML5 checks are merely a UX convenience and do not replace server-side validation."} ⏎ ```

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

{"answer": "no", "explanation": "Symfony hashes passwords (e.g., with bcrypt or argon2) and stores the hash, not the plain-text password, in the session or database."}

{"answer": "yes", "explanation": "Symfony's convention (since Flex/4.x) is to place each bundle's configuration in its own YAML file under config/packages/."}

{"answer": "yes", "explanation": "This is the standard pattern (e.g., in Symfony) where .env holds non-sensitive dev defaults committed to VCS, while .env.local holds real secrets and is git-ignored."}

{"answer": "debug:services", "explanation": "The Symfony command 'debug:services' lists all registered services and their aliases in the service container."}

```json ⏎ {"answer": "yes", "explanation": "The Container class exposes setParameter() as a public method that stores the value at runtime, so calling it from a controller is valid (though it won't affect already-instantiated services)."} ⏎ ```

{"answer": "no", "explanation": "Since Symfony 4.1, services are private by default and can only be fetched from the container if they are explicitly set as public or used as a controller, event listener, etc."}

{"answer": "no", "explanation": "Many Symfony bundles work out of the box without any configuration file in config/packages; configuration is only needed for bundles that require specific settings."}

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

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable in Symfony controls whether debug mode is enabled, which activates the profiler and Twig debugging features."}

{"answer": "no", "explanation": "Symfony Messenger allows multiple handlers to be registered for the same message class, and all matching handlers will be executed."}

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

{"answer": "messenger:consume", "explanation": "The Symfony Messenger command 'messenger:consume' starts the worker that processes queued messages."}

```json ⏎ {"answer": "no", "explanation": "The retry_strategy (max_retries, delay, multiplier, max_delay) is configured per Messenger bus, not per transport."} ⏎ ```

{"answer": "yes", "explanation": "Symfony Messenger uses the Symfony Serializer component by default, which serializes messages to JSON format."}

{"answer": "yes", "explanation": "Symfony Scheduler schedules tasks to run at defined intervals and integrates with Messenger to dispatch messages to the message bus on that schedule."}

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

{"answer": "yes", "explanation": "Laravel's Messenger allows you to add custom middleware to the pipeline and control their order relative to built-in ones."}

```json ⏎ {"answer": "yes", "explanation": "Symfony's official documentation states that releases come every 6 months (May and November), with a major version every 2 years."} ⏎ ```

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

```json ⏎ {"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations in favor of PHP 8 attributes; annotation-based routing and validation loaders were deprecated in 6.4 and removed in 7.0."} ⏎ ```

{"answer": "yes", "explanation": "AssetMapper is a Symfony component that handles CSS/JS asset management without requiring Node.js or Webpack, using importmap.php for module resolution."}

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

{"answer": "no", "explanation": "Symfony major versions remove deprecations introduced in the previous major version; that is precisely the purpose of a major release."}

{"answer": "yes", "explanation": "Each Symfony major release includes UPGRADE guide files (both per-component and a global one) that document breaking changes and deprecations."}

{"answer": "Asset Mapper", "explanation": "The Symfony Asset Mapper component (symfony/asset-mapper, introduced in Symfony 6.3) manages assets and importmaps without requiring Node.js or Webpack."}

```json ⏎ {"answer": "no", "explanation": "Symfony minor releases (x.2) typically ship at the end of November, so as of November 7, 2026, Symfony 8.2 would not yet have been released."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Following the six-month cycle from Symfony 7.0 (May 2024), Symfony 8.0 is expected in November 2026, not 8.2; 8.2 would be around November 2027."} ⏎ ```

{"answer": "8.2", "explanation": "Symfony releases minor versions every six months; after 8.1 (May 2026) comes 8.2 (November 2026)."}

```json ⏎ {"answer": "no", "explanation": "Symfony 8.2 would be a minor release (8.x line), not a major one; major releases are denoted by X.0 versions, and even those require migration rather than a full rewrite."} ⏎ ```

{"answer": "yes", "explanation": "PHP follows a policy where minor version upgrades within the same major version (e.g., 8.1 to 8.2) maintain backward compatibility and should not require code changes."}

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

{"answer": "no", "explanation": "Symfony 8.x is expected to require PHP 8.4 as its minimum version, not PHP 8.5; minor versions like 8.2 don't typically raise the minimum PHP requirement beyond what the major version set."}

```json ⏎ {"answer": "yes", "explanation": "Per Symfony's deprecation policy, deprecations introduced in a major version (8.x) are removed in the next major version (9.0), so they are not removed before 9.0."} ⏎ ```

{"answer": "no", "explanation": "Twig's {{ }} allows variables, operators, filters, Twig functions, and method calls on objects, but arbitrary PHP functions/code cannot be called directly without a Twig extension."}

{"answer": "yes", "explanation": "Twig enables auto-escaping with the 'html' strategy by default, so variables printed with {{ }} are HTML-escaped unless explicitly marked safe."}

{"answer": "yes", "explanation": "The |e (escape) filter in Twig defaults to HTML context escaping, converting characters like <, >, &, ' and \" to their HTML entities."}

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

{"answer": "yes", "explanation": "The |raw filter (as used in Twig and similar templating engines) outputs a value without auto-escaping, allowing raw HTML to be rendered."}

{"answer": "yes", "explanation": "In Twig, {{ }} outputs expression values, while {% %} is used for control structures like if, for, and set."}

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

{"answer": "dump", "explanation": "The dump() function in Twig is used to display the debug structure of a variable, provided by the Twig Debug extension."}

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JS library providing pre-built UI components (grid, navbar, modal, etc.), not an SPA framework like React or Angular."}

{"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 splits a row into 12 columns (not 16), and modern versions (Bootstrap 4+) use Flexbox rather than CSS floats."}

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

```json ⏎ {"answer": "no", "explanation": "The numbers in classes like .mt-3 do not represent direct multiples of $spacer; for example, .mt-1 equals $spacer/4 and .mt-3 equals $spacer, not 3×$spacer."} ⏎ ```

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

{"answer": "yes", "explanation": "Bootstrap 5 dropped its jQuery dependency and all interactive components are now built with vanilla JavaScript."}

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

{"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; you must explicitly run schema creation commands or migrations to create the database tables."}

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

{"answer": "no", "explanation": "In Doctrine ORM 3, EntityManager::merge() was removed (it was deprecated in ORM 2); the method no longer exists."}

{"answer": "yes", "explanation": "DQL operates at the object model level, using entity class names and their mapped fields rather than raw table and column names."}

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

{"answer": "no", "explanation": "DoctrineBundle does not automatically call flush() at the end of a request; you must explicitly call $entityManager->flush() to persist changes."}

{"answer": "yes", "explanation": "The Unit of Work tracks changes to managed entities by comparing their current state against a snapshot, so flush() alone is sufficient to commit modifications without calling persist() again."}

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

{"answer": "no", "explanation": "MVCC's entire purpose is to allow readers and writers to proceed concurrently without blocking each other; each transaction sees a consistent snapshot of the data."}

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

{"answer":"no","explanation":"While both involve sequences under the hood, SERIAL creates an explicit sequence object separate from the column, whereas GENERATED AS IDENTITY uses an internal mechanism where the sequence is implicitly tied to the column and they behave differently in edge cases like dropping the column."}

{"answer": "no", "explanation": "In PostgreSQL, NULL values are considered distinct from each other by default, so a UNIQUE constraint allows multiple rows with NULL in that 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 marks dead tuple space as reusable within the table file but does not return it to the operating system; only VACUUM FULL (or VACUUM FULL VERBOSE) shrinks the file and returns space to the OS."}

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

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

{"answer": "yes", "explanation": "PostgreSQL operates in autocommit mode by default, meaning each individual SQL statement is wrapped in its own implicit transaction that is automatically committed or rolled back."}

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

{"answer": "yes", "explanation": "Indexes help locate rows quickly for any DML operation (SELECT, UPDATE, DELETE) that uses a WHERE clause on an indexed column, avoiding a full table scan."}

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

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports real execution times and row counts, unlike plain EXPLAIN which only shows the plan without running it."}

{"answer": "pgvector", "explanation": "pgvector is a PostgreSQL extension that adds a vector type and vector indexes for efficient similarity search with embeddings."}

{"answer": "yes", "explanation": "A partial index is only built over rows that satisfy the WHERE condition, making it smaller and more efficient for targeted queries."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which tracks read/write dependencies and detects conflicts after the fact, rather than locking rows on read."}

{"answer": "yes", "explanation": "HTTP status 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 an empty response body, commonly returned after DELETE operations."}

{"answer": "yes", "explanation": "RFC 7231 explicitly lists DELETE among the idempotent methods: repeating a DELETE for the same resource does not change the outcome beyond the first invocation."}

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

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests was defined in RFC 6585 to indicate that a client has sent too many requests in a given amount of time, i.e., 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 explicitly states that PATCH is not idempotent, whereas PUT (defined in RFC 7231) is required to be idempotent."}

{"answer": "no", "explanation": "Using == is vulnerable to timing attacks and type juggling; hash_equals() should be used for constant-time comparison."}

{"answer": "yes", "explanation": "CSRF tokens are generated by the server, tied to the session, and verified server-side on state-changing requests like POST, PUT, or DELETE to ensure the request originated from the legitimate user."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to define the sources that are allowed to be loaded on a webpage, enabling CSP."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol; the access token grants access to resources rather than identifying the user (that's what OpenID Connect's ID token does)."}

```json ⏎ {"answer": "no", "explanation": "XSS is primarily prevented by context-aware output encoding when data is sent to the browser, not by input validation before storing in the database."} ⏎ ```

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

{"answer": "yes", "explanation": "Refresh tokens are designed to outlive access tokens and allow clients to obtain new access tokens without requiring the user to log in again."}

{"answer": "no", "explanation": "A salt does not need to be secret; it is typically stored alongside the hash and is used to recompute the hash during verification — its purpose is to prevent rainbow table attacks, not to add secrecy."}

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

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

{"answer": "no", "explanation": "A data provider is designed to supply multiple sets of arguments so the test runs once for each set, not just one."}

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

{"answer": "no", "explanation": "It's the opposite: a stub returns pre-defined data, while a mock verifies that specific methods were called with expected arguments."}

{"answer": "yes", "explanation": "In PHPUnit 10+, the #[DataProvider] attribute is the recommended replacement for the deprecated @dataProvider annotation."}

{"answer": "no", "explanation": "PHPUnit provides the @depends annotation (or depends() method) that allows a test to depend on the return value of another test."}

{"answer": "--random-order", "explanation": "The --random-order PHPUnit CLI option shuffles the order in which tests are executed."}

{"answer": "3-3", "explanation": "intdiv(7,2) is 3, intdiv(-7,2) is -3 (truncates toward zero), concatenated with dot operator 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 as numbers, and 1e1 (scientific notation for 10) equals 10."}

{"answer": "zero", "explanation": "In PHP (prior to 8), switch uses loose comparison (==), and a non-numeric string like 'a' == 0 evaluates to true, so case 0 matches."}

{"answer": "2c", "explanation": "strtr with an array replaces the longest matching key first, so 'ab' is matched and replaced with '2', leaving 'c' unchanged, resulting in '2c'."}

```json ⏎ {"answer": "[]", "explanation": "substr('hello', -10) returns an empty string because the negative start offset (-10) exceeds the string length (5)."} ⏎ ```

{"answer":"k,n,m","explanation":"The + operator performs array union where the left array takes precedence for duplicate keys, resulting in keys 'k','n','m' in that order."}

{"answer": "yxz", "explanation": "usort sorts by the third element (index 2), so [2,'y',1] comes first, then [1,'x',2] and [3,'z',2] (stable sort); array_column extracts index 1 giving ['y','x','z'], imploded to 'yxz'."}

{"answer": 4, "explanation": "The spread operator with 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 syntax ($p->g(...)) creates a Closure bound to the object instance; even after $p is set to null, the Closure holds a reference to the object, so it remains alive and $this->v is still 3."}

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

{"answer": 10, "explanation": "The set accessor doubles the value (5 * 2 = 10), and since accessors don't trigger on internal property access, the stored value is 10."}

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

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

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

{"answer": "second", "explanation": "The finally block throws a LogicException, which replaces the in-flight RuntimeException, and the outer catch catches the LogicException."}

{"answer": "App\\Foo|Baz", "explanation": "Baz::class resolves to App\\Foo (the aliased class via use), while \\Baz::class refers to the global class Baz, returning the string '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 holds a reference to the last element ($a[2]), so assigning $v = 99 changes $a[2] to 99."}

{"answer": 3, "explanation": "Static variables in methods are shared across all instances of the same class (and inherited subclasses share the same static), so each call increments the shared $n: 1, 2, 3."}

```json ⏎ {"answer": "", "explanation": "The generator is paused at the first yield (yield 1) after send(10), so it hasn't completed and getReturn() returns null, which echo outputs as an empty string."} ⏎ ```

```json ⏎ {"answer": "1,2,ok", "explanation": "yield from delegates to inner() which yields 1 and 2, then its return value 'ok' is captured in $r and yielded by outer(), producing the sequence 1,2,ok."} ⏎ ```

{"answer": "noyes", "explanation": "The hash was created with cost 4, so password_needs_rehash returns false (no) when checking against cost 4, and true (yes) when checking against cost 5."}

```json ⏎ {"answer": "strict-in", "explanation": "E_ALL includes E_STRICT (2048), so E_ALL & 2048 equals 2048 (not 0), making the condition false and selecting 'strict-in'."} ⏎ ```

```json ⏎ {"answer": "mapped", "explanation": "Symfony's HeaderBag strips the HTTP_ prefix and normalizes keys (underscores/hyphens, case), so HTTP_X_TOKEN is stored as X_TOKEN and retrieved correctly via get('X-Token')."} ⏎ ```

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

```json ⏎ {"answer": "same", "explanation": "Doctrine ORM's identity map ensures that find() returns the same object instance for the same entity ID, so both $a and $b reference the same object."} ⏎ ```

```json ⏎ {"answer": 0, "explanation": "Persisting then removing a new (unflushed) entity simply cancels the pending INSERT; Doctrine removes it from the newEntities collection without ever issuing a SQL statement, so the table remains empty."} ⏎ ```

{"answer": 1, "explanation": "COUNT(x) counts only non-NULL values in column x; since one row has NULL, the result is 1."}

{"answer": "10,30,60", "explanation": "The window function sum(x) OVER (ORDER BY id) produces running sums 10, 30, 60, which string_agg concatenates with commas into '10,30,60'."}

{"answer": "M1M2", "explanation": "The first middleware echoes 'M1' then delegates to the next, which echoes 'M2' then tries to call next() again (throwing a LogicException after the output)."}

```json ⏎ {"answer": 11, "explanation": "HandleMessageMiddleware calls all handlers registered for the message class sequentially, so both closures execute: $n += 1 then $n += 10, resulting in 11."} ⏎ ```

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

{"answer": 2, "explanation": "The UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, so it is only checked at COMMIT time, meaning both INSERTs succeed and count(*) returns 2."}

{"answer": 6, "explanation": "The --filter test_sum matches both test_sum and test_sum_abs (since filter does substring matching), each with 3 data sets from the provider, giving 3+3=6 tests."}

{"answer":"2, 1","explanation":"The data provider supplies two datasets ([1] and [-1]), so test_x runs twice; the first assertion (1>0) passes and the second (-1>0) fails."}

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

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

{"answer": "invalid_client", "explanation": "RFC 6749 Section 5.2 defines 'invalid_client' as the error returned when the client authentication failed, such as when the client was unknown to the authorization server."}

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

```json ⏎ {"answer": 0, "explanation": "The 'default' filter only returns the fallback when the value is null or undefined; since false is a defined non-null value, it passes through as-is, and false * 3 equals 0."} ⏎ ```

```json ⏎ {"answer": "a3", "explanation": "In Twig, the + operator has higher precedence than ~, so the expression is evaluated as 'a' ~ (1+2) = 'a' ~ 3 = 'a3'."} ⏎ ```

{"answer": 0, "explanation": "Assert\\NotBlank on an array checks if the array is non-empty; [''] has one element so it passes, resulting in 0 violations."}

{"answer": "invalid", "explanation": "When a Symfony form has not been submitted, isSynchronized() returns false, so isValid() returns false via short-circuit evaluation, outputting 'invalid'."}

```json ⏎ {"answer": "same", "explanation": "Services in Symfony's DI container are shared (singleton) by default, so both calls to get('a') return the same object instance."} ⏎ ```

```json ⏎ {"answer": "hi Bob!", "explanation": "During compile(), Symfony recursively resolves parameter references: %greeting% is replaced with 'hi %name%', then %name% is replaced with 'Bob', yielding 'hi Bob!'."} ⏎ ```

{"answer": 960, "explanation": "At 992px viewport, the lg breakpoint (≥992px) applies, giving .container a max-width of 960px in Bootstrap 5.3."}

```json ⏎ {"answer": "text-danger", "explanation": "In Bootstrap 5.3's CSS, text-danger is declared after text-primary with equal specificity, so it wins by source order in the cascade."} ⏎ ```

```json ⏎ {"answer": 2, "explanation": "The Domain class depends on Application (PlaceOrder) and Infrastructure (Db), both of which violate the rule that Domain may only depend on Domain."} ⏎ ```

{"answer": 3, "explanation": "The Domain class depends on two Infrastructure classes (Db, Logger) and one Application class (PlaceOrder), all violating the rule that 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 echoing both gives '10,15'."}

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

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

```json ⏎ {"answer": "yesno", "explanation": "newLazyGhost creates an uninitialized lazy object (isUninitializedLazyObject returns true), then accessing $o->v triggers initialization via the callback, after which it's no longer uninitialized (returns false)."} ⏎ ```

{"answer": "no", "explanation": "The Security Guard component was removed in Symfony 6.0, so AbstractGuardAuthenticator no longer exists in Symfony 8.1."}

```json ⏎ {"answer": "nono", "explanation": "In Symfony 8.1, AnnotationClassLoader was removed (deprecated in 7.0), and the replacement class is named AttributeLoader (not AttributeClassLoader), so both class_exists checks return false."} ⏎ ```