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

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

{"answer": "yes", "explanation": "The ?? operator is equivalent to isset($var) ? $var : default, and isset() returns false (not a warning) for undefined variables, so ?? never triggers undefined variable warnings."}

{"answer": "ab", "explanation": "PHP's echo statement accepts multiple comma-separated arguments and prints them sequentially without any separator."}

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

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

{"answer": "no", "explanation": "In PHP, the concatenation operator (.), addition (+), and subtraction (-) all share the same precedence level and are left-associative."}

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

{"answer": "sum: 5", "explanation": "The + operator has higher precedence than the . (concatenation) operator, so 2+3 is evaluated first, then concatenated with 'sum: '. "}

{"answer": "no", "explanation": "With ===, arrays must have the same key/value pairs in the same order to be considered equal; order only doesn't matter with ==."}

{"answer": "no", "explanation": "0 == false uses loose comparison (==) and actually returns true; strict comparison would be === which returns false."}

{"answer": "no", "explanation": "In PHP 8, when comparing a non-numeric string like 'abc' with an integer using ==, the integer is cast to a string, so 'abc' == '0' evaluates to false (unlike PHP 7 where it was true)."}

{"answer": "yes", "explanation": "In PHP, loose comparison (==) treats null as equal to 0, empty string \"\", and false, all evaluating to true."}

{"answer": 42, "explanation": "PHP casts the string by reading from left to right until it hits a non-numeric character, so '42abc' becomes the integer 42."}

{"answer": 10, "explanation": "PHP coerces the string '5' to an integer when using the + operator, so 5 + 5 = 10."}

{"answer": "no", "explanation": "In PHP, casting false to a string results in an empty string \"\", not \"0\"; it is true that casts to \"1\"."}

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

{"answer": "no", "explanation": "strrev() reverses a string byte-by-byte, which splits multi-byte UTF-8 characters and produces garbled output; you need mb_ functions (e.g., mb_strtolower with mbstr) to correctly reverse UTF-8."}

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

{"answer": "no", "explanation": "str_pad() can pad on the right, left, or both sides 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 (\\0, \\t, \\n, \\r, \\0, \\x0B), not just spaces."}

{"answer": 6, "explanation": "strlen counts bytes in UTF-8: 'h' (1) + 'é' (2) + 'l' (1) + 'l' (1) + 'o' (1) = 6 bytes."}

{"answer": "def", "explanation": "substr with a negative start position counts from the end of the string; -3 means the last 3 characters of 'abcdef', which is 'def'."}

{"answer": "no", "explanation": "In PHP, strings are passed by value; ucfirst() returns a new string with the first character uppercased rather than modifying the original variable in place."}

{"answer": "yes", "explanation": "Heredoc (<<EOF) allows variable interpolation, while nowdoc (<<'EOF') treats content as a literal string with no interpolation, similar to single-quoted strings."}

{"answer": "no", "explanation": "PHP's sort() re-indexes the array with sequential integer keys, so key-to-value associations are lost; use asort() to preserve keys."}

{"answer": "yes", "explanation": "In PHP, string keys that represent valid integers (like '5') are automatically cast to integer keys, so $arr['5'] and $arr[5] refer to the same element."}

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

{"answer": "yes", "explanation": "array_filter() without a callback keeps only elements that are truthy, effectively removing all falsy values (0, '', null, false, '0', empty array)."}

{"answer": "no", "explanation": "By default, the $preserve_keys parameter of array_slice() is false, so the resulting array is reindexed with sequential integer keys starting from 0."}

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

{"answer": 2, "explanation": "The + operator merges arrays keeping left-hand values for duplicate keys, resulting in ['a' => 1, 'b' => 2], which has 2 elements."}

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

{"answer": "no", "explanation": "In PHP, named arguments CAN be combined with argument unpacking (...$args) in the same function call, e.g. foo(a: 1, ...$args)."}

{"answer": "no", "explanation": "In PHP, closures do not automatically inherit the outer scope; you must explicitly import variables using the `use` keyword."}

{"answer": 3, "explanation": "func_num_args() returns the total number of arguments actually passed to the function (3), regardless of how many parameters are declared in the signature."}

{"answer": "no", "explanation": "An arrow function (fn) body is a single expression after =>, not a curly-brace block of multiple statements."}

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

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

{"answer": 5, "explanation": "The 'use ($x)' clause captures the value of $x (5) by value at closure creation time, so later reassigning $x to 7 does not affect the closure's captured copy."}

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

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

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

{"answer": "yes", "explanation": "In PHP, the 'final' keyword on a method prevents any subclass from overriding that method."}

{"answer": "no", "explanation": "In PHP, private properties are only accessible within the class that defines them and are not accessible in subclasses; only protected or public parent properties are accessible in child classes."}

{"answer": "class@anonymous", "explanation": "In PHP, get_class() on an anonymous class returns a name like 'class@anonymous/path/to/file.php:LINE\\0ADDR'; the part before the NUL byte without the file path is 'class@anonymous'."}

{"answer": "yes", "explanation": "In PHP, a private method is completely hidden from child classes, so the child is free to declare a method with the same name and any visibility without conflict—it's a new method, not an override."}

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

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

{"answer": "yes", "explanation": "PHP interfaces can declare public constants, which are accessible via the interface name."}

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

{"answer": "yes", "explanation": "PHP allows interfaces to declare static methods (since PHP 5.1), and any implementing class must provide a matching static method."}

{"answer": "no", "explanation": "PHP's instanceof operator checks both class inheritance and interface implementation, so it does not ignore interfaces."}

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

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared with public or protected visibility; only private abstract methods are disallowed."}

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

{"answer": "yes", "explanation": "Since PHP 8.2, traits are allowed to declare constants, which can be accessed via the 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 exception hierarchy."}

{"answer": "no", "explanation": "TypeError inherits from Error, not Exception; both Error and Exception are separate branches under Throwable, so catch(Exception) does not catch TypeError."}

{"answer": "no", "explanation": "The @ operator only suppresses errors (notices, warnings, etc.) via error_reporting; exceptions still propagate normally regardless of the @ operator."}

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

{"answer": "no", "explanation": "The finally block executes regardless of whether an exception was thrown, caught, or not; it always runs when the try-catch-finally structure is encountered."}

{"answer": "no", "explanation": "An exception thrown in a finally block replaces (overrides) any exception from the try 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 truthy values."}

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

{"answer": "no", "explanation": "The 'use' statement is a compile-time alias that simply maps a shorter name to a fully qualified class name; the actual class file is loaded via the autoloader only when the class is first referenced at runtime."}

{"answer": "function", "explanation": "In PHP, to import a function you write 'use function namespace\\functionName;', while 'use const' is used for importing constants."}

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

{"answer": "yes", "explanation": "Composer's vendor/autoload.php includes autoload_real.php which registers Composer's ClassLoader via spl_autoload_register()."}

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

{"answer": "no", "explanation": "An unqualified class name in `new` is first resolved relative to the current namespace; it only falls back to the global root if the class isn't found in the current namespace."}

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

{"answer": "yes", "explanation": "PHP allows a use statement inside a function body, and the alias then applies only within that function's scope."}

{"answer": "yes", "explanation": "In PHP, arrays are value types that are copied on assignment (using copy-on-write internally), unlike objects which are passed by handle/reference."}

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

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

{"answer": "no", "explanation": "$GLOBALS['x'] is a reference to the actual global variable, so unset($GLOBALS['x']) removes the global variable entirely for all code, not just for the current function."}

{"answer": 6, "explanation": "The function inc() takes $x by reference, so $n is incremented from 5 to 6, and echo prints 6."}

{"answer": "no", "explanation": "In PHP, foreach over an array by value iterates over a snapshot/copy of the array, so structural changes (adding or removing elements) made inside the loop are not visible in the same pass."}

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

{"answer": "no", "explanation": "In PHP, array keys are only int or string; the boolean key true is cast to the integer 1, not stored as bool."}

{"answer": "yes", "explanation": "In PHP, a generator function can use `return $value;`, and after exhausting the generator, the return value is accessible via the `Generator::getReturn()` method."}

{"answer": "no", "explanation": "A PHP generator is a one-shot iterator; once fully consumed, calling rewind() does not restart the underlying function, so it yields nothing on a second traversal."}

{"answer": "yes", "explanation": "The 'yield from' construct (as in Python) indeed delegates iteration to another iterable or generator, yielding each value it produces in sequence."}

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

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

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

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

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

{"answer": "yes", "explanation": "password_hash() in PHP 5.5+ automatically generates and embeds a random salt; the 'salt' option is purely optional and not required."}

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT is PASSWORD_BCRYPT (or PASSWORD_ARGON2ID in 8.4), not md5."}

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

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags from a string (useful against XSS), but SQL injection is defended against by prepared statements/parameterized queries, not by stripping tags."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID, invalidating the old one, which prevents an attacker who knows the pre-login session ID from hijacking the authenticated session (session fixation)."}

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

{"answer": "yes", "explanation": "session_destroy() only removes the session data on the server; the session cookie in the browser must be manually cleared (e.g., via setcookie with a past expiry) before or after destroying the session."}

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

{"answer": "none", "explanation": "array_find() is not a built-in PHP function; it does not exist in any PHP version (commonly confused with array_filter() or array_search())."}

{"answer": "yes", "explanation": "Property hooks (get/set defined inline in the property declaration) were introduced in PHP 8.4 via the Property Hooks RFC."}

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

{"answer": "8.4", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.4 to allow marking functions whose return value should not be silently discarded."}

{"answer": "8.4", "explanation": "The pipe operator (|>) was introduced in PHP 8.4, allowing functional pipeline-style chaining of expressions."}

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

{"answer": "none", "explanation": "array_first() and array_last() are not native PHP functions; they are helper functions provided by the Laravel framework, not introduced in any specific PHP version."}

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

{"answer": "8.4", "explanation": "The clamp() function was introduced in PHP 8.4, released in November 2024."}

{"answer": "no", "explanation": "The Context Managers v2 RFC for PHP was not adopted; it was rejected during the voting process, so context managers are not a feature of PHP as of November 2026."}

{"answer": "yes", "explanation": "The Bound-Erased Generic Types RFC for PHP was indeed voted down (declined) during the 2026 voting cycle."}

{"answer": "yes", "explanation": "The RFC to make ZTS (Zend Thread Safety) the default build was accepted for PHP 8.4, which would have been released before 2026-11-07."}

{"answer": "yes", "explanation": "PHP has not implemented true generics (parameterized types); as of PHP 8.5, only docblock-level @template annotations exist, which are not enforced at runtime."}

{"answer": "yes", "explanation": "PHP 8.5 was released in November 2025, and PHP 8.6's GA is expected on 2026-11-19, so as of 2026-11-07 the latest stable is indeed 8.5."}

{"answer": "yes", "explanation": "PHP went directly from 5.6 to 7.0; the 'PHP 6' development branch was merged into what became PHP 7 and was never released under the 6 name."}

{"answer": "no", "explanation": "The RFC proposing a #[\\Deprecated] attribute for PHP core was not adopted (it was rejected)."}

{"answer": "yes", "explanation": "In clean/onion architecture, the dependency rule states that inner layers (domain core) must not depend on outer layers; all dependencies point inward toward the center."}

{"answer": "yes", "explanation": "In DDD/clean architecture, domain entities must be framework-agnostic, depending only on native PHP language features and possibly the standard library, not on Doctrine or Symfony."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (view) layer; the business-logic layer consists of services, use cases, and domain objects that the controllers invoke."}

{"answer": "Domain", "explanation": "In the onion (hexagonal) architecture, the core Domain/Entities layer sits at the very center, surrounded by the Application, Interface Adapters, and Frameworks/Drivers layers."}

{"answer": "yes", "explanation": "Deptrac and similar static analysis tools can define layer rules and automatically fail the build when a forbidden cross-layer dependency is detected."}

{"answer": "no", "explanation": "Use cases (interactors) should depend on abstractions (interfaces like Repository), not concrete framework-specific types like HTTP requests or EntityManager, to remain decoupled and testable."}

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

{"answer": "yes", "explanation": "In Clean Architecture, the database driver sits in the outermost (infrastructure) layer, and the domain and use cases depend only on abstractions (interfaces) they define, so swapping the concrete database implementation affects only that outer layer."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of domain objects (entities and value objects) treated as a single unit for consistency, not a database table; it is a domain modeling concept, not a persistence/schema concept."}

{"answer": "yes", "explanation": "By definition, a Value Object is immutable and equality is determined by comparing its field values rather than object identity."}

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

{"answer": "yes", "explanation": "In DDD, a Repository is defined for an Aggregate Root only; entities within the aggregate are accessed through the root, not via their own repositories."}

{"answer": "yes", "explanation": "In Domain-Driven Design, ubiquitous language is the shared vocabulary used consistently by both developers and domain experts to ensure a common understanding of the domain model."}

{"answer": "frame", "explanation": "A frame defines the boundary within which a model's language is self-consistent, while outside it the same terms map to different models or meanings."}

{"answer": "no", "explanation": "DDD recommends a rich (fat) domain model where business logic lives inside the domain objects, not an anemic model with logic extracted into services."}

{"answer": "yes", "explanation": "In DDD, a Bounded Context ensures each context has its own independent model, so the same real-world concept (e.g., 'Customer') is typically represented by different, context-specific classes in different bounded contexts."}

{"answer": "yes", "explanation": "Symfony's DI container does not instantiate all services at boot; each service is only created (its factory called) the first time it is actually requested, which is the default lazy behavior."}

{"answer": "debug:router", "explanation": "The Symfony console command 'debug:router' (also 'router:debug' in newer versions) lists all registered routes."}

{"answer": "no", "explanation": "Autowiring's purpose is to automatically resolve and instantiate services based on type hints, so you do not need to manually declare every service in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes (extending Twig\\Template) and supports caching that compiled output between requests for performance."}

{"answer": "yes", "explanation": "In Symfony's dev environment, the compiled DI container is cached and only rebuilt when tracked files (e.g., service configs, classes) change, not on every request."}

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

{"answer": "no", "explanation": "Symfony's controller resolver calls the target method from outside the class, so it must be public; a private (or protected) method would throw an access error."}

{"answer": "no", "explanation": "Event subscribers and listeners are both dispatched by the EventDispatcher based on their numeric priority value; the EventSubscriberInterface itself does not grant any inherent priority over regular listeners."}

{"answer": "yes", "explanation": "Symfony 6.0 removed the legacy Guard system and standardized on the new authenticator architecture built around AuthenticatorInterface."}

{"answer": "IsGranted", "explanation": "The Symfony #[IsGranted] attribute (from Symfony/Security) checks a role or permission on a controller action and throws AccessDeniedException (403) if the user lacks it."}

{"answer": "yes", "explanation": "Voters in Symfony are the mechanism for object-level access control, and isGranted('EDIT', $post) delegates the check to registered voters."}

{"answer": "yes", "explanation": "In Symfony 7+ the legacy Doctrine Annotations (@Assert\\NotBlank) support was removed; validation constraints are now declared exclusively as native PHP attributes (#[Assert\\NotBlank])."}

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

{"answer": "yes", "explanation": "Symfony form validation always runs server-side upon submission; HTML5 client-side checks are merely a UX enhancement and are never relied upon for actual validation."}

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

{"answer": "no", "explanation": "Symfony stores the user's identifier (e.g., user ID or serialized token) in the session, while the password is kept hashed in the database and is only used transiently during authentication."}

{"answer": "yes", "explanation": "In modern Symfony (4+/Flex), the standard convention is to place one configuration file per bundle or topic in the config/packages/ directory (e.g., config/packages/doctrine.yaml, config/packages/monolog.yaml)."}

{"answer": "no", "explanation": "The standard PHP (e.g., Laravel) convention is that .env.example is committed with defaults, while .env (and .env.local) remain uncommitted; the statement incorrectly says .env itself is committed."}

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

{"answer": "yes", "explanation": "The Symfony container does have a setParameter() method that can be called from a controller; it works as long as the container is not frozen (e.g., in development mode), though it's not a recommended practice."}

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

{"answer": "no", "explanation": "Many Symfony bundles have sensible defaults and can work perfectly fine without any configuration file in config/packages; configuration is only required when a bundle needs specific settings."}

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

{"answer": "APP_DEBUG", "explanation": "In Symfony, the APP_DEBUG environment variable (defined in .env) controls whether debug mode is enabled, affecting the profiler, Twig debug output, and exception pages."}

{"answer": "no", "explanation": "In Symfony Messenger, a single message can be handled by multiple handlers, which are all invoked by default."}

{"answer": "no", "explanation": "The sync transport dispatches and handles the message immediately within the current process, rather than queuing it for a worker."}

{"answer": "messenger:consume", "explanation": "The Symfony command 'php bin/console messenger:consume' starts the worker that processes Messenger queue messages."}

{"answer": "no", "explanation": "In Symfony Messenger, the retry_strategy is configured per message bus (under framework.messenger.buses), not per transport."}

{"answer": "yes", "explanation": "Symfony Messenger's default serializer (SerializerSerializer) uses the Symfony Serializer component with 'json' as the default format."}

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

{"answer": "doctrine", "explanation": "Symfony Messenger's doctrine transport (doctrine://default) persists messages in a database table managed by Doctrine."}

{"answer": "yes", "explanation": "Symfony Messenger allows you to add custom middleware at any position in the pipeline, before or after built-in middleware, via the 'messenger.buses' configuration."}

{"answer": "yes", "explanation": "Symfony follows a release cadence where a new version ships every six months (May and November), with a major (breaking-change) release every two years."}

{"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 (doctrine/annotations) in favor of native PHP attributes."}

{"answer": "yes", "explanation": "Symfony's AssetMapper component handles CSS/JS bundling, minification, and import management without Node.js or webpack, using importmap.php to define JavaScript imports."}

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

{"answer": "no", "explanation": "In Symfony, the entire purpose of a major release is to remove the deprecations introduced in the previous major version; they do not persist."}

{"answer": "yes", "explanation": "Symfony provides an UPGRADE file (e.g., UPGRADE-6.0.md) with each major release documenting deprecations, breaking changes, and migration steps."}

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

{"answer": "no", "explanation": "Symfony typically releases new versions at the end of November (around Nov 29), so as of 2026-11-07, Symfony 8.2 would not yet have been released."}

{"answer": "yes", "explanation": "Symfony follows a six-month release cycle, so 8.0 (Nov 2025), 8.1 (May 2026), and 8.2 (Nov 2026) are consistent with the pattern."}

{"answer": "8.2", "explanation": "Symfony minor versions increment sequentially, so 8.2 follows 8.1."}

{"answer": "no", "explanation": "Symfony 8.2 is a minor release (not a major one), and even Symfony major releases are designed for incremental upgrades rather than complete rewrites."}

{"answer": "yes", "explanation": "PHP minor version updates (e.g., 8.1 → 8.2) are backward compatible, meaning existing code should continue to work without changes; only major version bumps (e.g., 7 → 8) introduce breaking changes."}

{"answer": "8.4", "explanation": "Symfony consistently ends each major branch at the .4 minor version (e.g., 4.4, 5.4, 6.4), which serves as the LTS release before the next major version, so 8.4 would be the last minor of the 8.x branch before 9.0."}

{"answer": "no", "explanation": "Symfony 8.x is expected to require PHP 8.3 or 8.4 as its minimum, not PHP 8.5; each major Symfony version typically bumps the PHP requirement by one minor version (e.g., Symfony 7 requires PHP 8.2)."}

{"answer": "yes", "explanation": "Symfony's deprecation policy requires deprecations to last at least two major versions, so those added in 8.x will not be removed until 10.0, which is after 9.0."}

{"answer": "no", "explanation": "Twig's {{ }} syntax uses its own limited expression language (variables, filters, function calls, operators) rather than allowing arbitrary PHP code directly."}

{"answer": "yes", "explanation": "Twig has auto-escaping enabled by default with the 'html' escape strategy, so variables printed with {{ }} are automatically HTML-escaped."}

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

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

{"answer": "yes", "explanation": "The |raw filter (in Twig) outputs a value without applying HTML auto-escaping."}

{"answer": "yes", "explanation": "In Twig, {{ }} is used to output/echo expressions, while {% %} is used for structural tags like if, for, set, block, etc."}

{"answer": "no", "explanation": "Twig allows declaring variables inside templates using the {% set %} tag, so values are not limited to coming from the controller."}

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

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JS toolkit providing pre-built UI components, while SPA frameworks are React, Angular, Vue, etc."}

{"answer": "container", "explanation": "The .container class in Bootstrap provides a responsive fixed-width container with a specific max-width at each breakpoint, while .container-fluid spans the full viewport width."}

{"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 named breakpoint infixes: sm, md, lg, xl, and xxl."}

{"answer": "no", "explanation": "The number in the utility class is an index into the $spacers map, not a direct multiplier of $spacer; for example, .mt-3 equals 1×$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, modals, and collapses on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 removed its jQuery dependency and all components are implemented in plain vanilla JavaScript."}

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

{"answer": "no", "explanation": "Doctrine ORM does not auto-create tables at runtime; you must explicitly create them via migrations or the schema tool before using the entities."}

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

{"answer": "no", "explanation": "EntityManager::merge() was removed in Doctrine ORM 3; even in ORM 2 it returned a new managed copy rather than making the passed object itself managed."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) operates at the object-model level, referencing entity classes and their mapped fields rather than raw database tables and columns."}

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

{"answer": "yes", "explanation": "By default, DoctrineBundle's auto_commit option is true, which causes the EntityManager to flush() and clear() pending changes at the end of each request via a kernel.response event listener."}

{"answer": "yes", "explanation": "In Doctrine ORM, once an entity is in the managed state, the Unit of Work tracks any property modifications, so flush() will generate and execute the UPDATE SQL without requiring an additional persist() call."}

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

{"answer": "no", "explanation": "MVCC in PostgreSQL allows readers and writers to operate concurrently without blocking each other, since each transaction sees its own consistent snapshot of the data."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command (or EXPLAIN PLAN in Oracle) displays the query execution plan without actually running the query."}

{"answer": "no", "explanation": "SERIAL is syntactic sugar that creates a separate sequence and a DEFAULT clause, while GENERATED AS IDENTITY is the SQL-standard identity column mechanism with different internal handling and constraints."}

{"answer": "no", "explanation": "In PostgreSQL, a standard UNIQUE constraint treats NULL values as distinct, so multiple rows can have NULL in that column by default."}

{"answer": "string_agg", "explanation": "PostgreSQL's string_agg() aggregate function concatenates strings with a user-specified separator."}

{"answer": "no", "explanation": "Plain VACUUM only marks dead tuples' space as reusable within the table; VACUUM FULL is what rewrites the table and returns the space to the operating system."}

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

{"answer": "no", "explanation": "READ COMMITTED only prevents dirty reads; non-repeatable reads are still possible because another transaction can commit a change to a row between two reads within the same transaction."}

{"answer": "yes", "explanation": "PostgreSQL defaults to autocommit mode, where each individual SQL statement is implicitly wrapped in its own transaction and committed automatically unless an explicit BEGIN is issued."}

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

{"answer": "yes", "explanation": "Indexes are used by the query optimizer to locate rows quickly for SELECT, UPDATE, and DELETE statements alike, so any DML operation with a WHERE clause on an indexed column benefits from the index."}

{"answer": "yes", "explanation": "SAVEPOINT in PostgreSQL allows you to roll back only a portion of a transaction to a specific named point, rather than rolling back the entire transaction."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query to report real execution times and row counts; plain EXPLAIN shows the plan without executing."}

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

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

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using SSI (Serializable Snapshot Isolation), which relies on MVCC snapshots and conflict detection at commit time rather than locking the rows a transaction reads."}

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

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

{"answer": "yes", "explanation": "Per RFC 9110, DELETE is idempotent: repeating the request for the same resource does not produce a different outcome beyond the initial deletion."}

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

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

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

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that the PATCH method is not idempotent, whereas PUT is defined as idempotent in RFC 7231."}

{"answer": "no", "explanation": "Plain == is vulnerable to timing attacks and PHP's loose type juggling; hash_equals() should be used for constant-time comparison of hashes."}

{"answer": "yes", "explanation": "A CSRF token is generated by the server, stored in the session, and validated server-side on state-changing requests like POST, PUT, or DELETE to ensure the request originated from a legitimate user session."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to enable and define a site's CSP, controlling which resources the browser is allowed to load."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol, not authentication; the access token grants access to resources within scopes, while identifying who the user is is the role of the ID token in OpenID Connect (a layer on top of OAuth 2.0)."}

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

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

{"answer": "yes", "explanation": "Refresh tokens are designed to be long-lived and are used to request new access tokens without requiring the user to re-authenticate."}

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

{"answer": "no", "explanation": "PHPUnit requires test classes to extend PHPUnit\\Framework\\TestCase in order to recognize and execute their test methods."}

{"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 can supply multiple sets of arguments, causing the test to run once per set; it is not limited to exactly one set."}

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

{"answer": "no", "explanation": "The definition is reversed: a stub returns predefined data, while a mock verifies that expected methods were called."}

{"answer": "yes", "explanation": "PHPUnit 10 introduced PHP 8 attributes as the preferred mechanism for test metadata, deprecating the old @dataProvider docblock annotation in favor of the #[DataProvider] attribute."}

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

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

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

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

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

{"answer": "zero", "explanation": "PHP switch uses loose comparison (==), and in PHP 7 'a' == 0 evaluates to true because a non-numeric string compared to an integer is converted to 0."}

{"answer": "2c", "explanation": "strtr() with an array matches the longest key first, so 'ab' (length 2) is matched before 'a' (length 1), replacing 'ab' with '2' and leaving 'c', giving '2c'."}

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

{"answer": "k,n,m", "explanation": "The + operator keeps all of $a's keys and adds only $b's keys not in $a, yielding keys k, n, m."}

{"answer": "yxz", "explanation": "After sorting by the third element (index 2), the order is [2,'y',1], [1,'x',2], [3,'z',2]; array_column extracts index 1 giving ['y','x','z'], and implode joins them to 'yxz'."}

{"answer": 4, "explanation": "Spreading an array with string keys uses named arguments, so $a=5 and $b=1, giving 5-1=4."}

{"answer": 3, "explanation": "The method g() is called immediately, returning 3 which is stored in $f; setting $p to null afterward doesn't affect the already-evaluated integer result."}

{"answer": "B", "explanation": "static::class uses late static binding, so it resolves to the child class B that was actually instantiated."}

{"answer": 10, "explanation": "The property setter multiplies the assigned value by 2, so setting $c->x = 5 stores 10, which is then echoed."}

{"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 static properties, so setting CX::$n does not affect CY::$n, which remains 0."}

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

{"answer": "second", "explanation": "When a finally block throws a new exception, it replaces the original exception, so the LogicException('second') is caught by the outer catch."}

{"answer": "App\\Foo|Baz", "explanation": "Baz is an alias for App\\Foo via the use statement, so Baz::class resolves to App\\Foo, while \\Baz::class refers to the global class Baz, giving the concatenated string 'App\\Foo|Baz'."}

{"answer": "noyes", "explanation": "class_exists('Foo') looks for a global class Foo (false, 'no'), while class_exists('Ns\\Foo') finds the class defined in namespace Ns (true, 'yes'), concatenating to 'noyes'."}

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

{"answer": 3, "explanation": "Static local variables in a method are shared per defining class; since B inherits inc() from A without redefining it, the same static $n is used across all calls, incrementing to 1, 2, 3."}

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

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

{"answer": "noyes", "explanation": "The first password_needs_rehash check returns false (cost matches at 4), and the second returns true (cost 5 differs from 4), so 'no' and 'yes' are concatenated."}

{"answer": "strict-in", "explanation": "E_ALL (32767) includes the E_STRICT bit (2048), so E_ALL & 2048 equals 2048, which is not === 0, yielding 'strict-in'."}

{"answer": "mapped", "explanation": "Symfony's HeaderBag normalizes HTTP_X_TOKEN to 'x-token', so headers->get('X-Token') correctly retrieves 'abc'."}

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

{"answer": "same", "explanation": "Doctrine ORM's identity map ensures that calling find() with the same class and ID within the same EntityManager returns the same PHP object instance, so spl_object_id() will match."}

{"answer": 0, "explanation": "When an entity is persisted and then removed before flush, Doctrine cancels the pending insertion (removes it from the new-entities set), so flush performs no INSERT or DELETE and the table remains empty."}

{"answer": 1, "explanation": "COUNT(x) counts only non-NULL values in column x; there is one row with x=1 and one with x=NULL, so the result is 1."}

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

{"answer": "M1M2", "explanation": "Each middleware echoes its tag in order (M1 then M2) as the request passes through the stack before the final handler is reached."}

{"answer": 11, "explanation": "HandleMessageMiddleware iterates through all handlers in the HandlersLocator for the message class, so both handlers are called: $n = 0 + 1 + 10 = 11."}

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

{"answer": 2, "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, the uniqueness check is postponed until the end of the transaction, so both INSERTs of the same value succeed within the same transaction, resulting in a count of 2."}

{"answer": 6, "explanation": "The --filter 'test_sum' matches both test_sum (3 data sets) and test_sum_abs (3 data sets), giving 6 tests total, while test_other is excluded."}

{"answer": "2, 1", "explanation": "The data provider yields two datasets ([1] and [-1]); $x=1 passes assertTrue, $x=-1 fails it, so 2 run, 1 fails."}

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

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

{"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, when the client_id is unknown/non-existent at the token endpoint, the error field is set to 'invalid_client'."}

{"answer": "fragment", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access token is passed in the URI fragment (after the #) of the redirect_uri to avoid it appearing in server logs."}

{"answer": 0, "explanation": "The default filter only triggers on null/undefined, so false|default(2) returns false, and false * 3 equals 0."}

{"answer": "a3", "explanation": "In Twig, the + operator has higher precedence than ~, so this is parsed as 'a' ~ (1+2) which concatenates 'a' with 3 to produce the string 'a3' without throwing any exception."}

{"answer": 0, "explanation": "The value is an array [''] with one element, so NotBlank (which checks if an array is empty) passes, resulting in 0 violations."}

{"answer": "invalid", "explanation": "A newly created Symfony form is not submitted, so isValid() returns false (isSubmitted() is false, short-circuiting the &&), printing 'invalid'."}

{"answer": "same", "explanation": "Symfony DI services are shared by default (setShared(true)), so calling get() twice returns the same cached instance."}

{"answer": "hi Bob!", "explanation": "Symfony's ContainerBuilder resolves %param% references during compile(), so %greeting% expands to 'hi Bob' and the final message is 'hi Bob!'."}

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

{"answer": "text-danger", "explanation": "In Bootstrap 5.3's generated CSS, .text-danger appears after .text-primary with equal specificity, so it wins the cascade."}

{"answer": 2, "explanation": "Domain layer can only depend on Domain, but this class depends on both Application (PlaceOrder) and Infrastructure (Db), resulting in 2 violations."}

{"answer": 3, "explanation": "The Domain layer can only depend on Domain, but the class references PlaceOrder (Application), Db (Infrastructure), and Logger (Infrastructure), giving 3 violations."}

{"answer": "10,15", "explanation": "The add method returns a new Money object with the sum (15), while the original $a retains its value of 10, so the output is '10,15'."}

{"answer": 1, "explanation": "The remove() method throws a DomainException before unsetting the item (since count === 1), so the item 'a' remains and count() 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 triggering, isUninitializedLazyObject returns true ('yes'); after accessing $o->v which triggers the ghost and runs the callback, it returns false ('no')."}

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

{"answer": "noyes", "explanation": "In Symfony 7.0+ (and thus 8.1), AnnotationClassLoader was removed (replaced by AttributeClassLoader), so class_exists returns false for the first and true for the second, concatenating to 'noyes'."}