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

{"answer": "no", "explanation": "Double-quoted strings support variable interpolation and more escape sequences (e.g., \\n, \\t), while single-quoted strings only interpret \\\\ and \\', so they are processed differently, not just at different speeds."}

{"answer": "yes", "explanation": "The ?? operator is equivalent to isset($a) ? $a : $b, so it checks with isset semantics and does not raise warnings for undefined variables."}

{"answer": "ab", "explanation": "echo with multiple comma-separated arguments concatenates and outputs them in order, producing 'ab'."}

{"answer": "yes", "explanation": "In PHP, print is a language construct that always returns the integer 1, which allows it to be used inside expressions (unlike echo, which returns nothing)."}

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

{"answer": "yes", "explanation": "In PHP's operator precedence, concatenation (.) ranks below addition/subtraction (+, -), so '1 + 2 . 3 + 4' evaluates as '(1+2) . (3+4)' = '37'."}

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

```json ⏎ {"answer": 3, "explanation": "Concatenation and addition have the same precedence and are left-associative, so it evaluates as ('sum: ' . 2) + 3 = 'sum: 2' + 3, where the non-numeric string is converted to 0, yielding 0 + 3 = 3."} ⏎ ```

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

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

{"answer": "no", "explanation": "In PHP 8, when comparing a non-numeric string to an integer, the integer is cast to a string instead, 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": "In PHP, casting a string to int with (int) parses the leading numeric portion and ignores trailing non-numeric characters, so '42abc' becomes 42."}

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

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

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

{"answer": "no", "explanation": "strrev() reverses bytes, not characters, so multi-byte UTF-8 characters get broken and reordered incorrectly."}

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

{"answer": "no", "explanation": "str_pad() supports right, left, and both-side padding via the pad_type parameter (STR_PAD_RIGHT, STR_PAD_LEFT, STR_PAD_BOTH)."}

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

{"answer": 6, "explanation": "In UTF-8, 'é' is encoded as 2 bytes (0xC3 0xA9), so the string 'héllo' is 1+2+1+1+1 = 6 bytes."}

{"answer": "def", "explanation": "substr with a negative start position counts from the end of the string, so -3 starts at the 4th character 'd' and returns 'def'."}

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

{"answer": "yes", "explanation": "Heredoc supports variable interpolation like double-quoted strings, while nowdoc (with single-quoted delimiter) does not, similar to single-quoted strings."}

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

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

{"answer": "no", "explanation": "The strict parameter of in_array() defaults to false, meaning it uses loose comparison (==) by default."}

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

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

{"answer": [20, 30], "explanation": "array_slice with offset 1 and length 2 returns the second and third elements of the array."}

{"answer": 2, "explanation": "Array union keeps the left array's value for duplicate keys, so 'a'=>1 is retained and 'b'=>2 is added, giving 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 officially added support for string keys when using the spread operator in array literals, removing the previous deprecation notice."}

{"answer": "no", "explanation": "In PHP 8.0+, named arguments can be combined with argument unpacking (e.g., foo(a: 1, ...$args))."}

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

{"answer": 3, "explanation": "func_num_args() returns the number of arguments actually passed to the function (3), not the number of declared parameters."}

{"answer": "no", "explanation": "Arrow functions (fn) in PHP have a single expression as their body using the => arrow, not a block of multiple statements in curly braces."}

{"answer": "no", "explanation": "Arrow functions (fn) in PHP capture outer variables by value at the time of creation, not by reference or lazily at use time."}

{"answer": "yes", "explanation": "In PHP, a static closure does not automatically capture $this from the enclosing scope, unlike a non-static closure which does."}

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

{"answer": "yes", "explanation": "In weak typing mode (the default), PHP coerces numeric strings like '5' to int when 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 with visibility modifiers."}

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

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

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

{"answer":"class@anonymous","explanation":"Anonymous classes in PHP have a generated name of the form 'class@anonymous\\0/file.php:line$0', so the part before the NUL byte is 'class@anonymous'."}

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

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

```json ⏎ {"answer": "Error", "explanation": "Reassigning a readonly property throws a TypeError, which is a subclass of Error, not 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 particular class or implements a particular interface."}

{"answer": "yes", "explanation": "PHP interfaces can declare static methods; they are implicitly public and abstract, and the implementing class must provide a corresponding static method."}

{"answer": "no", "explanation": "PHP's instanceof operator checks both class inheritance and interface implementation; it returns true if the object implements the given interface."}

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

{"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 of all enum cases, and there are exactly three cases defined: A, B, and C."}

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

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

```json ⏎ {"answer": "no", "explanation": "TypeError extends Error, not Exception; they are siblings under the Throwable interface, so catch(Exception) does not catch TypeError."} ⏎ ```

{"answer": "no", "explanation": "The @ operator only suppresses errors (warnings, notices, etc.), not exceptions, which are thrown and caught via throw/try-catch."}

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

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

```json ⏎ {"answer": "no", "explanation": "An exception thrown in a finally block will replace (mask) the exception from the try block and can also override a return value from the try block."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, any object cast to boolean always evaluates to true, including instances of Exception."}

{"answer": "yes", "explanation": "Shutdown functions registered via 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; the class file is only loaded when the class is actually referenced (e.g., instantiated), triggering the autoloader."}

{"answer": "function", "explanation": "In PHP, to import a function from a namespace you use 'use function', while 'use const' is 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, yielding src/Controller/Api/UserController.php."}

{"answer": "yes", "explanation": "Composer's vendor/autoload.php ultimately calls spl_autoload_register() to register its autoloader function with PHP's SPL autoload mechanism."}

{"answer": "yes", "explanation": "__NAMESPACE__ is a magic constant available since PHP 5.3 that resolves to the current namespace name (or an empty string in the global namespace)."}

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

{"answer": "yes", "explanation": "PSR-4 maps the base namespace 'App\\' to 'src/', the sub-namespace 'Model' to a 'Model/' subdirectory, and the class name 'User' to 'User.php', resulting in 'src/Model/User.php'."}

```json ⏎ {"answer": "no", "explanation": "While a use statement can syntactically be placed inside a function, it is a compile-time construct that still applies to the file scope, not just that function."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, arrays are copied on assignment (using copy-on-write since PHP 5.3) and are passed by value by default in function calls unless explicitly passed by reference with &."}

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

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

{"answer": "no", "explanation": "unset($GLOBALS['x']) inside a function removes the global variable entirely (globally), not just for that function's scope, because $GLOBALS is a direct reference to the global variables array."}

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

{"answer": "no", "explanation": "A foreach by value iterates over the array's elements as they existed at the start; newly added elements are not visited in the same pass, so it does not fully reflect live changes."}

{"answer": "no", "explanation": "Static properties belong to the class, not to individual instances; all instances share the same static property and changes are visible across all of them."}

{"answer": "no", "explanation": "In PHP, boolean array keys are cast to integers (true becomes 1, false becomes 0), not stored as bool."}

{"answer": "yes", "explanation": "In PHP 5.5+, a generator can use `return` with a value, and it is accessible via `$gen->getReturn()` after the generator is fully iterated."}

```json ⏎ {"answer": "no", "explanation": "Calling rewind() on a generator that has already been started (i.e., after the first next() call) throws a LogicException, so a fully consumed generator cannot be rewound and re-traversed."} ⏎ ```

{"answer": "no", "explanation": "yield from is a Python construct; PHP only has yield, not yield from."}

{"answer": "Generator", "explanation": "A function containing a yield statement is a generator function, and calling it returns a Generator object, so get_class() returns the string 'Generator'."}

{"answer": 3, "explanation": "The generator yields three values (1, 2, 3), iterator_to_array converts it to a 3-element array, and count returns 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (Last In, First Out) stack, not a FIFO queue; SplQueue is the one that 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 with foreach."}

{"answer": "no", "explanation": "ArrayObject implements the Iterator interface, which extends Traversable, 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, so no separate salt parameter is needed."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT in PHP 8 is an alias for PASSWORD_BCRYPT, which uses the bcrypt algorithm, not md5."}

{"answer": true, "explanation": "password_verify checks if the given password matches the hash, and since the same string 'secret' was used to create the hash, it returns true."}

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags and helps prevent XSS, but SQL injection is mitigated by prepared statements or proper escaping, not by stripping tags."}

{"answer": "yes", "explanation": "session_regenerate_id() replaces the current session ID with a new one, which is the primary defense against session fixation attacks, typically called upon login when the session's privilege level changes."}

{"answer": "php_sapi_name", "explanation": "php_sapi_name() returns the SAPI name of the current PHP interpreter, such as 'cli' or 'fpm-fcgi'."}

{"answer": "yes", "explanation": "session_destroy() only removes the session data stored on the server; to clear the session cookie in the browser, you must separately call setcookie() with a past expiration time."}

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

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

{"answer": "yes", "explanation": "PHP 8.4 introduced property hooks, allowing get and set accessors to be defined directly within the property declaration."}

{"answer": "yes", "explanation": "Asymmetric visibility (e.g., public private(set) string $name) is a new feature introduced in PHP 8.4, allowing different visibility for reading vs. writing a property."}

{"answer": "8.4", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.4, allowing developers to mark function return values that should not be silently discarded."}

{"answer": "not yet", "explanation": "The pipe operator (|>) is still an open RFC and has not been included in any stable PHP release as of PHP 8.4."}

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

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

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

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

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

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

```json ⏎ {"answer": "yes", "explanation": "An RFC to make ZTS (Zend Thread Safety) the default build mode in PHP was accepted, as the gap between NTS and ZTS builds had narrowed enough to make ZTS safe as the default."} ⏎ ```

{"answer": "yes", "explanation": "PHP 8.5 does not introduce native generics; parameterized types remain absent from the language spec."}

{"answer": "yes", "explanation": "PHP follows a yearly release cycle in November; PHP 8.5 was released in November 2025 and PHP 8.6 is expected to go GA on 2026-11-19, so as of 2026-11-07, 8.5 is indeed the latest stable version."}

{"answer": "yes", "explanation": "PHP went directly from 5.6 (released 2014) to 7.0 (released 2015), skipping the 6.x series entirely."}

{"answer": "no", "explanation": "The RFC for the #[\\Deprecated] attribute was not accepted for PHP 8.4; it received a minority vote and was deferred."}

{"answer": "yes", "explanation": "In both Clean and Onion architecture, the Dependency Rule dictates that dependencies point only inward, so inner layers (domain/core) have no knowledge of outer layers (frameworks, UI, DB)."}

{"answer": "yes", "explanation": "Domain entities should be pure PHP objects with no framework dependencies (Doctrine, Symfony), keeping the domain layer decoupled from infrastructure concerns."}

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

{"answer": "Entity", "explanation": "In the onion architecture, the innermost layer at the center consists of the core domain entities and business rules."}

{"answer":"yes","explanation":"Deptrac is a PHP static analysis tool that enforces layer dependency rules and fails the build when a forbidden cross-layer call is detected."}

{"answer": "no", "explanation": "A use case (interactor) should be framework-agnostic: it should accept simple data/DTOs rather than an HTTP request, and depend on repository/gateway abstractions rather than a concrete EntityManager, keeping it decoupled from transport and infrastructure layers."}

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

{"answer": "yes", "explanation": "In Clean Architecture, the domain and use cases depend on abstractions (e.g., a Repository interface), so swapping the database only requires changing the concrete Repository implementation in the outer layers."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of domain objects treated as a unit for business consistency; it is a domain concept, not a database table."}

{"answer": "yes", "explanation": "Value Objects are defined by their immutability and value-based equality, distinguishing them from entities which are identified by a unique identity."}

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

{"answer": "yes", "explanation": "In DDD, a repository is defined per aggregate root, and all entities within that aggregate are accessed through the root rather than having their own repositories."}

{"answer": "yes", "explanation": "Ubiquitous Language is a DDD concept referring to the shared vocabulary consistently used by both developers and domain experts throughout the project."}

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

{"answer": "no", "explanation": "DDD recommends a rich domain model where objects encapsulate both state and behavior; anemic models are considered an anti-pattern in DDD."}

{"answer":"yes","explanation":"In DDD, a Bounded Context defines a boundary where a model has a specific meaning, so the same real-world concept (e.g., 'Product') is typically modeled as a different class in each context with its own attributes and behaviors."}

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

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

{"answer": "no", "explanation": "Autowiring 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 that extend Twig\\Template and caches them on disk to avoid recompilation on subsequent requests."}

{"answer": "yes", "explanation": "Symfony caches the compiled DI container and only rebuilds it when tracked files (configs, classes, etc.) are detected as changed, not on every request."}

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

{"answer": "no", "explanation": "Symfony's ControllerResolver requires controller action methods to be public; private methods are not callable from outside the class and will cause an error."}

```json ⏎ {"answer": "no", "explanation": "Event subscribers are internally just a convenience for registering multiple listeners; they are ordered by the same priority/registration-order mechanism as regular listeners, with no inherent precedence."} ⏎ ```

{"answer": "yes", "explanation": "Symfony 6.0 removed the legacy guard authentication system, which was deprecated in 5.3, and the new authentication system is built around AuthenticatorInterface (authenticator classes)."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute in Symfony checks if a user has a specific role or permission on a controller method, throwing a 403 AccessDeniedException if they don't."}

{"answer": "yes", "explanation": "Symfony Voters are the mechanism for checking access to a specific object, and isGranted('EDIT', $post) is the standard way to use them."}

{"answer": "yes", "explanation": "Symfony 7 requires PHP 8.2+ and uses native PHP attributes (#[Assert\NotBlank]) for validation; the doctrine/annotations package is no longer a framework dependency."}

{"answer": "yes", "explanation": "Symfony's Form component has CSRF protection enabled by default; the form automatically adds and validates a CSRF token on submission unless explicitly disabled."}

{"answer": "yes", "explanation": "Symfony's form validation is always executed server-side; HTML5 client-side validation is merely a UX convenience and does not replace Symfony's own validation process."}

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

{"answer": "no", "explanation": "Symfony stores the user identifier and roles in the session, not the plain-text password; the password is only used to verify against the hashed value in the database during login."}

{"answer": "yes", "explanation": "In modern Symfony, the convention is to place bundle and topic-specific configuration in config/packages/ with one YAML file per bundle or topic."}

```json ⏎ {"answer": "yes", "explanation": "This is the standard Symfony convention where .env contains default dev values committed to the repo, and .env.local holds local secrets and is gitignored."} ⏎ ```

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

```json ⏎ {"answer": "yes", "explanation": "The Container class has a setParameter() method that can be called from a controller to store a new value, which will be returned by subsequent getParameter() calls, though services that already received the parameter via compilation won't be affected."} ⏎ ```

{"answer": "no", "explanation": "Since Symfony 4.0, services are private (public: false) by default, allowing the container to optimize and remove unused services."}

{"answer": "no", "explanation": "Most Symfony bundles work without a configuration file in config/packages because they ship with sensible defaults; configuration is optional, not mandatory."}

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

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable controls whether Symfony runs in debug mode, enabling the profiler and Twig debug toolbar."}

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

{"answer": "no", "explanation": "The sync transport handles the message immediately within the same process without queueing it for a worker, unlike async transports."}

{"answer": "messenger:consume", "explanation": "In Symfony, the messenger:consume command starts the worker that processes messages from the Messenger queue/transport."}

```json ⏎ {"answer": "no", "explanation": "The retry_strategy is configured globally in the framework config or per message via the envelope, not per transport."} ⏎ ```

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

```json ⏎ {"answer": "no", "explanation": "Symfony Scheduler schedules and executes tasks (e.g., method calls) at defined intervals; it does not inherently produce messages or dispatch them through Messenger, though it can be used in combination with Messenger."} ⏎ ```

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

{"answer": "yes", "explanation": "Laravel's Messenger allows you to add custom middleware via the through() method on a command class, and you can order them before or after built-in middleware like authorization."}

```json ⏎ {"answer": "no", "explanation": "Symfony major releases (e.g., 5.0, 6.0, 7.0) come approximately every year, not every two years; minor/feature releases do come every six months in May and November."} ⏎ ```

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

{"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations, requiring the use of PHP attributes instead."}

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

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

{"answer": "no", "explanation": "Symfony major releases are specifically where deprecations from the previous major version can be removed, as that's the allowed breaking change."}

{"answer": "yes", "explanation": "Symfony has always included UPGRADE-*.md files in its repository documenting the changes between major versions."}

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

```json ⏎ {"answer": "no", "explanation": "Following Symfony's 6-month release cadence, 8.0 would be released around May 2026 and 8.1 around November 2026, making 8.2 not expected until around May 2027."} ⏎ ```

{"answer": "no", "explanation": "Following the six-month cycle, Symfony 8.0 would be released in November 2026, while 8.2 would be expected in November 2027."}

{"answer": 8.2, "explanation": "Symfony versions increment sequentially, so the version after 8.1 is 8.2."}

{"answer": "no", "explanation": "Symfony 8.2 is a minor release (major version 8, minor version 2), not a major release; major releases are indicated by the first number changing (e.g., 8.0), and even those don't typically require a full rewrite."}

```json ⏎ {"answer": "yes", "explanation": "PHP's compatibility policy guarantees that minor version updates within the same major series (e.g., 8.1 → 8.2) are backward compatible, with breaking changes reserved only for major version bumps."} ⏎ ```

```json ⏎ {"answer": "8.4", "explanation": "Symfony releases minor versions every 6 months (May and November), and the last minor of each major branch is always .4, released in November alongside the next major version."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Symfony 8.x is expected to require PHP 8.4 (following the pattern of Symfony 7.x requiring PHP 8.2), not PHP 8.5."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony, deprecations introduced in a minor version of the 8.x branch are kept throughout all 8.x releases and are only removed in the next major version, 9.0."}

{"answer": "no", "explanation": "Inside {{ }} Twig uses its own expression language (variables, operators, filters, built-in functions), not arbitrary PHP code."}

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

{"answer": "yes", "explanation": "The Twig |e (escape) filter by default escapes a string for safe HTML output, though other contexts like js, css, and url can also be specified."}

{"answer": "numberformat", "explanation": "The 'numberformat' filter in twig/intl-extra uses PHP's NumberFormatter to format a number according to a given locale."}

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

{"answer": "yes", "explanation": "In Twig, {{ }} outputs the result of an expression, while {% %} is used for structural tags like if, for, and set."}

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

{"answer": "dump", "explanation": "The Twig function 'dump()' is used to dump the debug structure of a variable (array, object, etc.)."}

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

{"answer": "container", "explanation": "The .container class provides a responsive fixed-width container that adjusts its max-width at each breakpoint, while .container-fluid is full-width."}

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

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

{"answer": "yes", "explanation": "In Bootstrap, spacing utilities like .mt-3 or .px-2 multiply the $spacer variable by the number (e.g., $spacer * 3)."}

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

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

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

{"answer": "no", "explanation": "Doctrine ORM does not auto-create tables at runtime; you must use migrations or the schema-tool to create/update the database schema."}

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

```json ⏎ {"answer": "no", "explanation": "EntityManager::merge() returns a new managed copy of the entity; the originally passed object remains detached, not managed."} ⏎ ```

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is designed to query entities and their mapped fields, abstracting away the underlying database tables and columns."}

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

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

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

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

{"answer": "no", "explanation": "MVCC in PostgreSQL ensures that readers do NOT block writers and writers do NOT block readers, as each transaction sees its own snapshot of the data."}

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

{"answer": "no", "explanation": "SERIAL is a shortcut that creates a separate sequence and sets a column default, while GENERATED AS IDENTITY creates a true identity column with distinct SQL-standard semantics (e.g., OVERRIDING SYSTEM VALUE); they are related but different mechanisms."}

```json ⏎ {"answer": "no", "explanation": "By default, PostgreSQL treats NULLs as distinct in UNIQUE constraints, so multiple rows can have NULL in the column."} ⏎ ```

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

{"answer":"no","explanation":"Plain VACUUM only marks space as reusable for future inserts within the same table; it does not return the space to the operating system (that requires VACUUM FULL)."}

{"answer": "PARTITION BY", "explanation": "The PARTITION BY clause in a window function divides rows into groups over which the function is computed, similar to GROUP BY but without collapsing rows."}

{"answer": "no", "explanation": "READ COMMITTED only prevents dirty reads; it does not protect against non-repeatable reads, which are prevented by REPEATABLE READ or higher."}

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

{"answer": "COMMIT", "explanation": "The COMMIT SQL command permanently saves all changes made during the current transaction."}

{"answer": "yes", "explanation": "Indexes speed up not only SELECT queries but also UPDATE and DELETE operations that filter on indexed columns, as the database can quickly locate the target rows."}

{"answer": "yes", "explanation": "SAVEPOINT allows you to roll back to a specific point within a transaction without aborting the entire transaction, effectively undoing only the statements after that savepoint."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query to gather real execution statistics, whereas plain EXPLAIN only shows the plan without executing."}

{"answer": "pgvector", "explanation": "pgvector is the PostgreSQL extension that adds vector types and indexes (IVFFlat, HNSW) for similarity search with embeddings."}

{"answer": "yes", "explanation": "A partial index (CREATE INDEX ... WHERE ...) only stores index entries for rows that satisfy the specified condition, reducing index size and improving performance for queries targeting those rows."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which does not lock read rows but instead detects write-skew conflicts at commit time."}

{"answer": "yes", "explanation": "HTTP 201 'Created' is the standard status code indicating that a new resource has been successfully created as a result of the request."}

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

{"answer": "yes", "explanation": "Per the HTTP specification (RFC 9110), DELETE is considered idempotent: repeating the same DELETE request has the same effect as a single request, as the resource is already removed after the first call."}

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

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

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

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not idempotent in general, while PUT is idempotent by definition per RFC 7231."}

{"answer": "no", "explanation": "Using == is vulnerable to timing attacks; the correct approach is hash_equals() which performs a constant-time comparison."}

{"answer": "yes", "explanation": "CSRF tokens are generated server-side, tied to the user's session, and validated by the server on state-changing requests like POST, PUT, or DELETE."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to configure a CSP for a web page."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol; the access token represents a set of permissions/scopes rather than user identity (that's OpenID Connect's role via the ID token)."}

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

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

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

{"answer": "no", "explanation": "A salt does not need to be secret; it is typically stored alongside the hash (e.g., embedded in bcrypt) so that the correct hash can be recomputed for verification."}

{"answer": "no", "explanation": "PHPUnit identifies test classes by checking that they extend PHPUnit\\Framework\\TestCase; without it, the class is not recognized as a test class."}

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

{"answer": "no", "explanation": "A data provider allows a test to run with multiple (one or more) sets of arguments, not exactly one."}

{"answer": "expectException", "explanation": "In PHPUnit, $this->expectException(ClassName::class) is used to declare that an exception of the specified class is expected to be thrown."}

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

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

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

{"answer": "--order-by=random", "explanation": "PHPUnit's --order-by=random option shuffles the test execution order randomly."}

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

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

{"answer": "false", "explanation": "In PHP, comparing two strings with == performs a string comparison, and '1e1' and '10' are different strings, so the result is false."}

{"answer": "zero", "explanation": "In PHP 8, comparing a non-numeric string to an integer casts the string to int, so 'a' == 0 is true, matching case 0."}

{"answer": "2c", "explanation": "strtr with an array processes keys longest-first, so 'ab' is replaced with '2' first, then 'a' is searched in the remaining string '2c' but not found."}

{"answer": "[]", "explanation": "substr('hello', -10) returns an empty string because the offset -10 goes beyond the start of a 5-character string, so the result is '[]'."}

{"answer": "k,n,m", "explanation": "The + operator merges arrays keeping left-side values for duplicate keys, resulting in keys k, n, m."}

{"answer": "yxz", "explanation": "Sorting by the third element gives [2,'y',1], [1,'x',2], [3,'z',2], then array_column extracts 'y','x','z' and implode joins them into 'yxz'."}

{"answer": 4, "explanation": "The spread operator with string keys maps values to named parameters: $a=5, $b=1, so the result is 5-1=4."}

```json ⏎ {"answer": 3, "explanation": "The first-class callable $p->g(...) creates a closure bound to the object, so even after $p is set to null, the closure still holds a reference to the object and $this->v is still 3."} ⏎ ```

{"answer": "B", "explanation": "static::class uses late static binding and returns the class name of the instance that was called, which is B."}

```json ⏎ {"answer": 10, "explanation": "The setter hook doubles the value (5*2=10) and assigns it to the backing value via $this->x, which bypasses the hook; reading $c->x returns the backing value 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 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": "Throwing a new exception in a finally block replaces the original exception, so the LogicException('second') propagates and is caught by the outer catch."}

{"answer": "App\\Foo|Baz", "explanation": "Baz::class resolves to the aliased App\\Foo, while \\Baz::class references the global namespace's Baz which has no alias, so it just outputs Baz."}

{"answer": "noyes", "explanation": "class_exists('Foo') looks for a global class Foo (not found), while class_exists('Ns\\Foo') finds the namespaced class Foo that was defined."}

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

{"answer": 3, "explanation": "Static variables in PHP methods are shared across the class hierarchy (parent and child share the same static variable), so each call increments the same counter: 1, 2, 3."}

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

{"answer": "1,2,ok", "explanation": "yield from delegates inner's yields (1, 2) to the caller and assigns inner's return value ('ok') to $r, which is then yielded as the third value."}

{"answer": "noyes", "explanation": "The first check returns false (cost 4 matches cost 4), outputting 'no'; the second returns true (cost 4 doesn't match cost 5), outputting 'yes'."}

{"answer": "strict-out", "explanation": "In PHP 8.5, E_STRICT (2048) was removed from E_ALL, so the bitwise AND yields 0, selecting 'strict-out'."}

{"answer": "mapped", "explanation": "Symfony's HeaderBag strips the HTTP_ prefix and converts underscores to hyphens, so HTTP_X_TOKEN becomes X-Token and matches the get() call."}

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

```json ⏎ {"answer": "same", "explanation": "Doctrine ORM's UnitOfWork identity map ensures that find() returns the same managed instance for a given identifier, so $a and $b are the same object."} ⏎ ```

```json ⏎ {"answer": 0, "explanation": "When an entity is both persisted (new) and removed before flush, Doctrine's UnitOfWork cancels the insert — it removes the entity from the new-entities collection and does not issue an INSERT, so the table remains empty."} ⏎ ```

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

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

{"answer": "M1M2", "explanation": "The MessageBus dispatches through middleware in array order, so Trace('M1') echoes 'M1' first, then calls the next middleware Trace('M2') which echoes 'M2' before delegating to the final handler."}

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

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

```json ⏎ {"answer": 2, "explanation": "The UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, so it is not checked until transaction end, allowing both inserts to succeed and the count to be 2."} ⏎ ```

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

{"answer": "2, 1", "explanation": "The DataProvider returns two rows ([1] and [-1]), so 2 tests run; test_x(-1) fails because -1 > 0 is false."}

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

{"answer": "GET", "explanation": "The -G flag tells curl to pass the -d data as a GET query string instead of a POST body."}

{"answer": "unauthorized_client", "explanation": "RFC 6749 §5.2 specifies that when the client is not recognized (e.g., non-existent client_id), the token endpoint returns the error 'unauthorized_client'."}

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

```json ⏎ {"answer": 0, "explanation": "false is defined and not null, so default(2) returns false; then false * 3 evaluates to 0 * 3 = 0."} ⏎ ```

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

{"answer": 0, "explanation": "The array [''] is not empty (it has one element), so the NotBlank constraint passes, resulting in zero violations."}

{"answer": "invalid", "explanation": "A Symfony form that has never been submitted returns false from isValid(), so the ternary outputs 'invalid'."}

{"answer": "same", "explanation": "Symfony's ContainerBuilder caches public service instances, so repeated calls to get('a') return the same object."}

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

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

```json ⏎ {"answer": "text-danger", "explanation": "In Bootstrap 5.3's generated CSS, text-danger appears after text-primary in the stylesheet (order: primary, secondary, success, danger...), so with equal specificity the later rule wins."} ⏎ ```

```json ⏎ {"answer": 2, "explanation": "The Domain layer can only depend on Domain, but this class imports from Application (PlaceOrder) and Infrastructure (Db), giving 2 violations."} ⏎ ```

{"answer": 3, "explanation": "BillingService is in the Domain layer, which may only depend on Domain, but it depends on Application (PlaceOrder) and Infrastructure (Db, Logger), giving 3 violations."}

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

{"answer": 1, "explanation": "The remove() method throws a DomainException before unsetting the item, so the item remains in the array and count() still returns 1."}

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

{"answer": "yesno", "explanation": "Before accessing $o->v, the lazy ghost is uninitialized (yes); after accessing $o->v, the initializer has been called and the object is no longer uninitialized (no)."}

{"answer": "no", "explanation": "The Guard security component (Symfony\\Component\\Security\\Guard) was removed in Symfony 7.0, so in 8.1 the class no longer exists and class_exists() returns false."}

```json ⏎ {"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 7.0 (deprecated in 6.4), while AttributeClassLoader replaced it and exists in 8.1."} ⏎ ```