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

{"answer": "no", "explanation": "Double-quoted strings support variable interpolation and escape sequences like \\n, \\t, while single-quoted strings only recognize \\\\ and \\' as escapes, so the processing is fundamentally different, not just a speed difference."}

{"answer": "yes", "explanation": "The null coalescing operator (??) is equivalent to isset($var) ? $var : default and does not trigger warnings or notices for undefined variables, unlike the plain ternary operator."}

{"answer": "ab", "explanation": "In PHP, echo can take multiple arguments separated by commas and concatenates them, printing 'ab'."}

{"answer": "no", "explanation": "While print does return the value 1, it is a language construct (not a function), so it cannot be used inside an expression (e.g., you cannot write echo 2 * print \"hello\";)."}

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

{"answer": "yes", "explanation": "In PHP's operator precedence table, the concatenation operator (.) ranks below + and -, so arithmetic is evaluated before concatenation."}

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

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

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

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

{"answer": "no", "explanation": "In PHP 8, a non-numeric string like \"abc\" is compared as a string, so 0 is cast to \"0\" and \"abc\" != \"0\", yielding false."}

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

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

{"answer": 10, "explanation": "In PHP, the numeric string '5' is coerced to integer 5, so 5 + 5 equals 10."}

{"answer": "no", "explanation": "In PHP, casting false to a string results in an empty string \"\", not \"0\"; it is 0 (integer) that becomes \"0\" when cast to string."}

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

{"answer": "no", "explanation": "strrev() reverses a string byte-by-byte, which corrupts multi-byte UTF-8 characters; mb_strrev() or similar is needed for proper UTF-8 reversal."}

{"answer": "yes", "explanation": "str_contains() checks if the needle 'world' exists within the haystack 'Hello world', which 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 (\" \\t\\n\\r\\0\\x0B\"), not just spaces."}

{"answer": 6, "explanation": "In UTF-8, 'é' is encoded as 2 bytes (0xC3 0xA9) while 'h', 'l', 'l', 'o' are each 1 byte, giving a total of 6 bytes."}

{"answer": "def", "explanation": "substr with a negative start position (-3) begins 3 characters from the end of the string, returning the last 3 characters 'def'."}

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

{"answer": "yes", "explanation": "Heredoc supports variable interpolation (like double-quoted strings), while nowdoc (quoted delimiter) treats the content as a single-quoted string, so variables are not interpolated."}

{"answer": "no", "explanation": "PHP's sort() reindexes the array numerically and does not preserve key-to-value associations; asort() is the function that does."}

{"answer": "yes", "explanation": "In PHP, numeric string keys like '5' are automatically cast to integer 5 when used as array keys."}

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

{"answer": "yes", "explanation": "Without a callback, array_filter() removes all falsy values (false, 0, 0.0, '', '0', null, []) from the array."}

{"answer": "no", "explanation": "The $preserve_keys parameter of array_slice() defaults to false, meaning the array is re-indexed with sequential integer keys starting at 0."}

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

{"answer": 2, "explanation": "The + operator keeps left-hand keys on conflict, so 'a'=>1 is preserved and 'b'=>2 is added, giving a 2-element array."}

{"answer": "no", "explanation": "In PHP 8.1, the array spread operator in array literals only supports integer keys; spreading an array with string keys throws a TypeError."}

{"answer": "no", "explanation": "PHP does allow combining named arguments with argument unpacking (...$args) in the same function call, as long as the rules about argument ordering are respected."}

{"answer": "no", "explanation": "In PHP, a closure (anonymous function) has its own scope and cannot access outer variables unless they are explicitly imported with the `use` keyword."}

{"answer": 3, "explanation": "func_num_args() returns the number of arguments actually passed to the function call, regardless of the number of declared parameters, so f(1, 2, 3) passes 3 arguments."}

{"answer": "no", "explanation": "An arrow function (fn) in PHP has a single-expression body introduced by '=>' and does not use curly braces; multiple statements require a regular closure with a block body."}

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

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

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

{"answer": "yes", "explanation": "In PHP's default weak typing mode (without declare(strict_types=1)), the string \"5\" is automatically coerced to the integer 5 when passed to an int parameter, so it is allowed."}

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, allowing properties to be declared directly in constructor parameters with visibility modifiers and types."}

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

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

{"answer": "no", "explanation": "In PHP, private properties are only accessible within the class that declares them and are not visible to subclasses (unlike protected properties)."}

{"answer": "class@anonymous", "explanation": "Anonymous classes in PHP are named 'class@anonymous' followed by a NUL byte and the file path/line number, so the part before the NUL byte is 'class@anonymous'."}

{"answer": "yes", "explanation": "In PHP, private methods are not visible to child classes, so a child can freely redeclare a method with the same name at any visibility level without conflict."}

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

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP throws an \\Error (not an \\Exception), with a message like 'readonly property … may not be written'."}

{"answer": "yes", "explanation": "PHP interfaces can declare constants (since PHP 5.0), which are implicitly public and final, and can be accessed via the interface name."}

{"answer": "instanceof", "explanation": "In PHP, 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 (abstract) methods, which implementing classes must also define as static."}

{"answer": "no", "explanation": "PHP's instanceof operator checks both class inheritance and interface implementations, so an object can be instanceof an interface it implements."}

{"answer": "no", "explanation": "In PHP, interface methods are abstract and cannot have a body/implementation, whereas trait methods can have a concrete default implementation."}

{"answer": "yes", "explanation": "In PHP, abstract methods can have public, protected, or final visibility; only private is disallowed."}

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

{"answer": "yes", "explanation": "Since PHP 8.3, traits can declare constants, which can be accessed via the class that uses the trait."}

{"answer": "yes", "explanation": "In PHP 7+, the Throwable interface is implemented by both Exception and Error, making it their common ancestor."}

{"answer": "no", "explanation": "In PHP, TypeError extends Error (not Exception); both Exception and Error implement Throwable, so catching Exception does not catch TypeError."}

{"answer": "no", "explanation": "The @ operator only suppresses error reporting (notices, warnings, etc.); exceptions still propagate normally unless caught by try/catch."}

{"answer": "ArithmeticError", "explanation": "intdiv(5, 0) throws an ArithmeticError (a subclass of Error) when the divisor is zero."}

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

{"answer": "no", "explanation": "In PHP, an exception thrown in a finally block overrides the normal completion or the caught exception, so it does affect the observable result of the try-catch-finally construct."}

{"answer": "yes", "explanation": "In PHP, any object instance (including a new Exception) is truthy when cast to bool, so (bool) new Exception('x') returns true."}

{"answer": "yes", "explanation": "Functions registered with register_shutdown_function() are executed during the script shutdown phase, which is triggered by exit(), normal script completion, or fatal errors."}

{"answer": "no", "explanation": "The use statement only creates an alias at compile time; the class file is actually loaded (via autoload) when the class is first referenced."}

{"answer": "function", "explanation": "In PHP, to import a function via a use statement, you write 'use function Namespace\\functionName;' using the keyword 'function'."}

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 strips the 'App\\' prefix, converts the remaining namespace separators (\\) to directory separators (/), and appends .php, yielding src/Controller/Api/UserController.php."}

{"answer": "yes", "explanation": "Composer's vendor/autoload.php ultimately calls spl_autoload_register() to register its ClassLoader for automatic class loading."}

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

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

{"answer": "yes", "explanation": "PSR-4 maps the sub-namespace Model\\User to the relative path Model/User.php under the base directory src/, giving src/Model/User.php."}

{"answer": "yes", "explanation": "PHP allows use statements inside a function body, and the alias/import is scoped only to that function's block."}

{"answer": "yes", "explanation": "In PHP, arrays are copied on assignment (copy-on-write), meaning each variable holds its own independent copy rather than a reference to the same data."}

{"answer": 2, "explanation": "In PHP, arrays are copied by value on assignment, so modifying $b does not affect $a, which still contains [1, 2]."}

{"answer": "yes", "explanation": "In PHP, variables in the global scope are not visible inside functions unless explicitly brought in via the global keyword, $GLOBALS array, or passed as parameters."}

{"answer": "no", "explanation": "unset($GLOBALS['x']) inside a function removes the variable from the global scope entirely, not just for that function's scope."}

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

{"answer": "no", "explanation": "PHP's foreach iterates over a snapshot of the array taken at the start of the loop, so adding, removing, or reordering elements inside the loop does not affect the current iteration."}

{"answer": "no", "explanation": "A static property belongs to the class itself and is shared across all instances, so changes in one object are visible in others; instance (non-static) properties are the ones that belong to each object separately."}

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

{"answer": "yes", "explanation": "Since PHP 5.5, a generator can use return with a value, and that value is accessible via the Generator::getReturn() method after the generator completes."}

{"answer": "no", "explanation": "In PHP, generators are one-shot iterators; once fully consumed, calling rewind() throws a RuntimeException and the generator cannot be traversed again."}

{"answer": "yes", "explanation": "The yield from construct (in Python) does indeed delegate iteration/traversal to another generator or any iterable."}

{"answer": "Generator", "explanation": "Calling a generator function returns an instance of the built-in Generator class, so get_class() on it returns the string 'Generator'."}

{"answer": 3, "explanation": "The generator yields 1, 2, 3 from the array [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, while a FIFO queue is implemented by SplQueue."}

{"answer": "yes", "explanation": "ArrayIterator is a built-in PHP class that wraps an array and implements the Iterator interface for traversal."}

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

{"answer": "yes", "explanation": "password_hash() internally generates a random salt and embeds it in the returned hash string; there is no separate salt parameter to pass."}

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

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

{"answer": "no", "explanation": "strip_tags() removes HTML and PHP tags to help mitigate XSS, but SQL injection is prevented by prepared statements/parameterized queries, not by stripping HTML tags."}

{"answer": "yes", "explanation": "session_regenerate_id() replaces the current session ID with a new one, preventing an attacker from exploiting a known (fixed) session ID after a user logs in."}

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

{"answer": "yes", "explanation": "session_destroy() only removes the session data on the server; the PHPSESSID cookie in the browser must be manually expired (e.g., via setcookie) to be removed."}

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

{"answer": "8.3", "explanation": "The array_find() function, which returns the first element matching a callback (similar to JavaScript's Array.find()), was introduced in PHP 8.3."}

{"answer": "yes", "explanation": "Property hooks (get/set/unset defined inline in a property declaration) were introduced as a major new feature in PHP 8.4."}

{"answer": "yes", "explanation": "PHP 8.4 introduced asymmetric visibility, allowing properties to have different read and write access levels (e.g., public private(set) string $name)."}

{"answer": 8.4, "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.4 to signal that a function's return value should not be discarded by the caller."}

{"answer": "8.4", "explanation": "The pipe operator |> was introduced in PHP 8.4 as part of the language's continued evolution with new syntactic features."}

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

{"answer": "8.4", "explanation": "The array_first() and array_last() functions were introduced in PHP 8.4 as part of the new set of array helper functions."}

{"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 as part of the clamp_v2 RFC."}

{"answer": "no", "explanation": "There is no adopted PHP RFC called 'Context Managers v2'; it appears to be a fabricated or non-existent RFC in the PHP standards process."}

{"answer": "yes", "explanation": "The PHP RFC for Bound-Erased Generic Types (generics) was voted down and declined, meaning PHP still lacks built-in generics support."}

{"answer": "no", "explanation": "As of late 2026, PHP has not accepted an RFC to make ZTS (Zend Thread Safe) the default build type; NTS remains the default while ZTS is available as an option."}

{"answer": "yes", "explanation": "PHP has never shipped engine-level generics; even as of PHP 8.5, parameterized types remain absent (only docblock @template hints exist for static analysis)."}

{"answer": "yes", "explanation": "PHP follows an annual November release cycle; PHP 8.5 was released in November 2025 and PHP 8.6 GA is scheduled for November 19, 2026, so as of November 7, 2026, 8.5 is indeed the latest stable."}

{"answer": "yes", "explanation": "PHP went directly from the 5.x line (ending at 5.6) to 7.0 in December 2015; no PHP 6 was ever released."}

{"answer": "no", "explanation": "The RFC for a built-in #[\\Deprecated] attribute was proposed but was rejected (not adopted) during the PHP RFC voting process."}

{"answer": "yes", "explanation": "In Clean/Onion Architecture, the dependency rule dictates that inner layers (domain) must not depend on outer layers (framework, UI, DB); all dependencies point inward toward the core business logic."}

{"answer": "yes", "explanation": "In DDD/clean architecture, domain entities are pure PHP objects that depend only on the language and possibly the standard library, not on Doctrine or Symfony."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation/view layer; the fact that they call use cases makes them clients of the business-logic layer, not part of it."}

{"answer": "Domain", "explanation": "In onion architecture, the Domain (enterprise business rules) sits at the very center, surrounded by Application and Delivery layers."}

{"answer": "yes", "explanation": "Tools like deptrac (Dependency and Layer Rules Checker) automatically enforce predefined layer-dependency rules and report failures when a forbidden cross-layer call is detected."}

{"answer": "no", "explanation": "In Clean Architecture, use cases (interactors) should be framework-agnostic and depend on domain objects and repository interfaces, not on infrastructure-specific types like HTTP requests or EntityManagers, to keep them testable and decoupled."}

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

{"answer": "yes", "explanation": "In clean architecture, the database is an outer infrastructure detail; the domain and use cases depend only on abstractions (e.g., repository interfaces), so swapping the DB engine requires changes only in the adapter/infrastructure layer."}

{"answer": "no", "explanation": "In DDD, an aggregate is a domain-level cluster of entities and value objects with a defined consistency boundary; it is a business concept, not a technical one like a database table (an aggregate may map to one or many tables)."}

{"answer": "yes", "explanation": "Value Objects are immutable and define equality by their field values rather than by a unique identity, which is the defining characteristic that distinguishes them from Entities in DDD."}

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

{"answer": "yes", "explanation": "In DDD, a repository is defined for the Aggregate Root to encapsulate access to the entire aggregate, rather than creating separate repositories for each entity within it."}

{"answer": "yes", "explanation": "Ubiquitous language, a key concept in Domain-Driven Design, is the shared vocabulary used consistently by both developers and domain experts to ensure clear communication and alignment between the model and the business domain."}

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

{"answer": "no", "explanation": "DDD recommends a rich domain model where entities and aggregates encapsulate both state and business logic, rather than an anemic model that delegates all behavior to external services."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a Bounded Context explicitly limits a model to a particular purpose, so the same real-world concept (e.g., 'Product') is represented by a different class in each context with potentially different attributes and behaviors."}

{"answer": "yes", "explanation": "Symfony's DI container does not instantiate services until they are first requested, making lazy creation the default behavior."}

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

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

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes and stores them in a cache directory, so subsequent requests reuse the cached compiled class instead of recompiling."}

{"answer": "yes", "explanation": "In Symfony's dev environment, the DI container is compiled and cached; it is only rebuilt when tracked files (services, configs, etc.) have changed, not on every request."}

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

{"answer": "no", "explanation": "Symfony controller action methods must be public; the routing/ControllerResolver expects to invoke them as public methods, so private (or protected) actions will not work with standard routing."}

{"answer": "no", "explanation": "Priority is determined by the integer priority value assigned to each listener/subscriber, not by whether it's registered as a subscriber or a listener; a subscriber can have lower priority than a regular listener."}

{"answer": "yes", "explanation": "Symfony 6.0 removed the legacy guard system entirely, and authentication is now built around the new AuthenticatorInterface-based system introduced in Symfony 5.3."}

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

{"answer": "yes", "explanation": "Symfony Voters are the built-in mechanism for object-level access control, used via isGranted('EDIT', $post) to check permissions on a specific object instance."}

{"answer": "yes", "explanation": "In Symfony 7 the Doctrine Annotations component was removed; validation constraints in PHP code must now use PHP 8 attributes (e.g. #[Assert\\NotBlank]) instead of the old @Assert\\NotBlank annotation syntax."}

{"answer": "yes", "explanation": "Symfony's Form component has CSRF protection enabled by default (the 'csrf_protection' form option defaults to true), automatically adding and validating a token on submission."}

{"answer": "yes", "explanation": "Symfony always performs server-side form validation independently of any client-side HTML5 checks; passing client-side validation does not skip the server-side validation."}

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

{"answer": "no", "explanation": "Symfony stores the user's identity (e.g., user ID) in the session, not the password; passwords are hashed (e.g., bcrypt, Argon2) and kept in the database."}

{"answer": "yes", "explanation": "In Symfony Flex projects, bundle and topic-specific configuration files are stored in config/packages/, with one YAML file per bundle or concern (e.g., framework.yaml, doctrine.yaml)."}

{"answer": "yes", "explanation": "This is the standard Symfony (and general Dotenv) convention: .env with dev defaults is committed, while .env.local (or .env.local.php) holds real secrets and is added to .gitignore."}

{"answer": "debug:container", "explanation": "The Symfony command 'debug:container' (also known as 'container:debug' in older versions) lists all registered services and their aliases in the service container."}

{"answer": "yes", "explanation": "Container::setParameter() simply writes to the internal $parameters array without checking the frozen state, so calling it from a controller at runtime does update the parameter (though it's generally considered an anti-pattern)."}

{"answer": "no", "explanation": "Since Symfony 4.0, services are private by default (public: false); they must be explicitly marked public to be fetched directly from the container."}

{"answer": "no", "explanation": "Bundles in Symfony can work with their default configuration; a config file in config/packages is only needed if you want to customize the bundle's settings."}

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

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable in .env file controls Symfony's debug mode, enabling the profiler and Twig debugging features when set to true."}

{"answer": "no", "explanation": "Symfony Messenger allows multiple handlers to be registered for the same message; you can configure routing to dispatch a message to more than one handler."}

{"answer": "no", "explanation": "The sync transport dispatches the message immediately to a listener in the same process without any queue or worker; it does not queue the message at all."}

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

{"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy (max_retries, delay, multiplier, max_delay) is configured per individual transport in the framework messenger configuration."}

{"answer": "yes", "explanation": "Symfony Messenger's default serializer uses JSON as the encoding format out of the box."}

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

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

{"answer": "yes", "explanation": "Symfony Messenger's middleware pipeline is extensible; custom middleware can be registered and positioned before or after the built-in middleware via configuration."}

{"answer": "yes", "explanation": "Symfony follows a schedule where major versions are released approximately every two years (in November), and minor releases occur every six months in May and November."}

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

{"answer": "yes", "explanation": "Symfony 7.0 still supports docblock annotations (e.g. @Route, @Assert) though they are deprecated in favor of PHP 8 attributes; full removal is planned for Symfony 8.0."}

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

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release with 2 years of bug fixes and 4 years of security fixes, as even minor versions are LTS."}

{"answer": "no", "explanation": "In Symfony, deprecations introduced in a major version are removed in the next major version, so moving to a new major release does remove the previous branch's deprecations."}

{"answer": "yes", "explanation": "Symfony ships an UPGRADE-<major>.<minor>.md file with each major release documenting breaking changes and deprecations."}

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

{"answer": "yes", "explanation": "Symfony 8.0 was released in November 2025, and minor versions follow monthly, so 8.2 would have been released well before November 2026."}

{"answer": "yes", "explanation": "Symfony follows a six-month release cycle with even minor versions in November, so 8.2 would indeed be scheduled for November 2026."}

{"answer": "8.2", "explanation": "Following Symfony's release cadence (X.0 in November, X.1 in May, X.2 in November), the version after 8.1 (May 2026) is 8.2 (November 2026)."}

{"answer": "no", "explanation": "Symfony 8.2 is a minor (patch-level) release within the 8.x major line, so it is backward-compatible and does not require rewriting; only major releases (e.g., 8.0) can introduce breaking changes."}

{"answer": "yes", "explanation": "Within the same major version (8.x), PHP follows backward compatibility: minor releases (8.1 → 8.2) add new features without removing or altering existing behavior, so no code changes are required."}

{"answer": "8.4", "explanation": "Symfony follows a pattern of releasing minor versions .0 through .4 per major branch, so the last minor version of 8.x before 9.0 is 8.4."}

{"answer": "no", "explanation": "Symfony's minimum PHP version is typically set at the major-version level (e.g., Symfony 8.0), and minor releases like 8.2 maintain that same baseline; it is not certain that 8.2 specifically bumps the requirement to PHP 8.5."}

{"answer": "yes", "explanation": "Symfony's deprecation policy guarantees that deprecations introduced in a given major version (8.x) are only removed in the next major version (9.0), so they persist throughout all 8.x releases."}

{"answer": "no", "explanation": "Twig's {{ }} block uses its own templating expression language (variables, filters, operators), not raw/arbitrary PHP code."}

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

{"answer": "yes", "explanation": "The Twig |e (escape) filter defaults to escaping for the HTML context using htmlspecialchars with ENT_QUOTES."}

{"answer": "number_format", "explanation": "The twig/intl-extra package provides the number_format filter which uses PHP's intl extension to format a number according to a given locale."}

{"answer": "yes", "explanation": "In Twig (the template engine commonly used with PHP), the |raw filter outputs a value without auto-escaping, treating it as safe HTML."}

{"answer": "yes", "explanation": "In Twig, double curly braces {{ }} output/echo an expression's value, while percent braces {% %} execute structural tags such as 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' %}, so values do not exclusively come 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 CSS framework with optional JS plugins providing pre-built UI components; it is not an SPA framework like React, Angular, or Vue."}

{"answer": "container", "explanation": "The Bootstrap 'container' class provides a responsive fixed-width container that has a max-width that changes at each breakpoint (e.g., 720px at md, 960px at lg, 1140px at xl)."}

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

{"answer": "yes", "explanation": "In Bootstrap 5, the breakpoint infixes used in class names are sm, md, lg, xl, and xxl (xs is the base and requires no infix), making exactly five."}

{"answer": "yes", "explanation": "In Bootstrap's spacing system, utility classes like .mt-3 or .px-2 generate values that are the numeric suffix multiplied by $spacer (e.g., .mt-3 = 3 * $spacer)."}

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

{"answer": "yes", "explanation": "Bootstrap 5 dropped its jQuery dependency and all components are built with plain 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 automatically create tables at runtime; you must explicitly run a schema tool or migration command (e.g., doctrine:schema:create or doctrine:migrations:migrate) to create the database tables."}

{"answer": "persist", "explanation": "EntityManager::persist() marks a new entity as managed (persistent) and schedules an INSERT to be executed only when flush() is called."}

{"answer": "no", "explanation": "EntityManager::merge() does exist in Doctrine ORM 3, but it returns a new managed copy rather than making the passed (detached) object itself managed; the original object remains detached."}

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

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

{"answer": "no", "explanation": "DoctrineBundle in Symfony calls EntityManager::close() at the end of a request to release the connection, but it does NOT automatically call flush(); you must call flush() explicitly in your code."}

{"answer": "yes", "explanation": "The Unit of Work automatically detects property changes on managed entities via change-set computation, so flush() alone commits them without needing a redundant persist() call."}

{"answer": "no", "explanation": "Doctrine's remove() only schedules the entity for deletion 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; readers see a snapshot of the data and writers create new row versions, so they do not block one another."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command displays a query's execution plan (table access methods, indexes used, join order) without actually running the query."}

{"answer": "no", "explanation": "SERIAL is a PostgreSQL-specific convenience macro that creates a separate sequence, a column, a default expression, and an ownership link, while GENERATED AS IDENTITY is a distinct SQL-standard mechanism with its own rules (e.g., GENERATED BY DEFAULT/ALWAYS, ALTER IDENTITY, DROP IDENTITY); they are similar in purpose but not the same mechanism."}

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

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

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

{"answer": "PARTITION BY", "explanation": "In SQL window functions, the PARTITION BY clause divides rows into groups over which the window function is computed."}

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

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

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

{"answer": "yes", "explanation": "Indexes are used to quickly locate rows, so UPDATE and DELETE statements with a WHERE clause on an indexed column also benefit from the index, not just SELECT."}

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

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query to collect real performance statistics; plain EXPLAIN (without ANALYZE) shows the plan without executing."}

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

{"answer": "yes", "explanation": "A partial index (CREATE INDEX ... WHERE ...) in PostgreSQL indexes only those rows that satisfy the given WHERE condition, leaving the other rows out of the index."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE via Serializable Snapshot Isolation (SSI) with predicate locking and post-hoc conflict detection, not by locking the rows a transaction reads (that is SQL Server's approach)."}

{"answer": "yes", "explanation": "HTTP 201 'Created' is returned when a request has been fulfilled and a new resource has been created, typically in response to a POST request."}

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

{"answer": "yes", "explanation": "RFC 9110 explicitly lists DELETE among the idempotent methods, meaning repeated identical DELETE requests have the same intended effect on the server as a single request."}

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

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

{"answer": "no", "explanation": "Using plain == is insufficient; you should use hash_equals() for a constant-time comparison (or at least ===) to avoid type-juggling and timing attacks."}

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

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to specify which sources of content are trusted by the browser, enabling CSP protection."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol, not an authentication protocol; the access token grants permission to access resources, while it is the ID token (from OpenID Connect) that identifies who the user is."}

{"answer": "no", "explanation": "XSS is primarily an output-side vulnerability prevented by encoding/escaping data when rendering it in the response, not by validating input before storing it in the database."}

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

{"answer": "yes", "explanation": "A refresh token has a longer expiration than an access token and is specifically designed to 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 and its purpose is uniqueness per user, not secrecy."}

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

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

{"answer": "no", "explanation": "A data provider is specifically designed to supply multiple sets of arguments so the same test method runs multiple times with different inputs."}

{"answer": "expectException", "explanation": "PHPUnit's expectException() method declares an expectation that an exception of the given class will be thrown during test execution."}

{"answer": "no", "explanation": "It's the opposite: a stub only returns predefined data, while a mock both returns data and verifies (records/sets expectations on) which methods were called."}

{"answer": "yes", "explanation": "In PHPUnit 10+, docblock annotations like @dataProvider are deprecated in favor of PHP 8 attributes such as #[DataProvider]."}

{"answer": "no", "explanation": "PHPUnit does allow test dependencies via the @depends annotation or the depend() method, letting one test use the return value of another."}

{"answer": "--random-order", "explanation": "The --random-order PHPUnit CLI option shuffles test execution order."}

{"answer": "3-3", "explanation": "intdiv(7,2) returns 3 and intdiv(-7,2) returns -3 (truncates toward zero), and the dot operator concatenates them into the string '3-3'."}

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

{"answer": "true", "explanation": "Both '1e1' and '10' are numeric strings, so PHP compares them numerically: 1e1 (which equals 10) == 10 is true, so 'true' is echoed."}

{"answer": "zero", "explanation": "PHP's switch uses loose comparison (==), and 'a' == 0 evaluates to true because the non-numeric string 'a' is cast to the integer 0."}

{"answer": "2c", "explanation": "strtr with an array replaces keys longest-first, so 'ab' is matched before 'a', resulting in '2c'."}

{"answer": "[]", "explanation": "substr('hello', -10) returns an empty string because the absolute value of the start position (10) exceeds the string length (5), so the output is just the brackets '[]'."}

{"answer": "k,n,m", "explanation": "The array union operator (+) keeps $a's values for duplicate keys and appends $b's unique keys, so array_keys gives ['k','n','m'] which implode joins as 'k,n,m'."}

{"answer": "yxz", "explanation": "The array is sorted by the third element (index 2): [2,'y',1] (1), [1,'x',2] (2), [3,'z',2] (2), then array_column extracts index 1 giving ['y','x','z'], which implode concatenates to 'yxz'."}

{"answer": 4, "explanation": "Spreading a named array maps values by key to parameters, so $a=5 and $b=1, and f returns 5-1=4."}

{"answer": 3, "explanation": "First-class callable syntax $p->g(...) creates a Closure that captures the object reference; setting $p=null afterward doesn't affect the closure, so $f() still calls g() on the original object, returning the private $v which is 3."}

{"answer": "B", "explanation": "static::class uses late static binding, so it returns the name of the class the object was instantiated from, which is B."}

{"answer": 10, "explanation": "The set hook multiplies the assigned value by 2 (5*2=10), storing 10 as the backing value; no get hook is defined, so reading the property returns 10."}

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

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

{"answer": 2, "explanation": "In PHP, when both try and finally blocks contain return statements, the return value from the finally block overrides the one from the try block, so the function returns 2."}

{"answer": "second", "explanation": "When a finally block throws an exception, it 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 App\\Foo due to the use alias, while \\Baz::class refers to the global namespace class Baz."}

{"answer": "noyes", "explanation": "class_exists('Foo') looks for the global class Foo which doesn't exist (the class is Ns\\Foo), while class_exists('Ns\\Foo') finds the class defined in the Ns namespace."}

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

{"answer": 3, "explanation": "Since B does not override inc(), both $a->inc() and $b->inc() call the same method with the same static variable: 1, 2, then 3."}

{"answer": 11, "explanation": "send(10) assigns 10 to $x, then the generator returns $x + 1 = 11, which is retrieved by getReturn()."}

{"answer": "1,2,ok", "explanation": "yield from inner() delegates yielding of 1 and 2, captures inner's return value 'ok' into $r, then outer yields $r, so iterator_to_array produces [1, 2, 'ok'] and implode gives '1,2,ok'."}

{"answer": "noyes", "explanation": "The first call checks if a cost-4 hash needs rehashing at cost 4 (no), the second checks at cost 5 (yes), so the output is 'noyes'."}

{"answer": "strict-out", "explanation": "E_STRICT (2048) was removed from E_ALL starting in PHP 8.4, so in PHP 8.5 the bitwise AND yields 0, making the condition true."}

{"answer": "mapped", "explanation": "Symfony's Request::create maps the HTTP_X_TOKEN server variable to the header 'x-token', and HeaderBag::get() is case-insensitive, so get('X-Token') returns 'abc', making the strict comparison true."}

{"answer": "BCA", "explanation": "Listeners are invoked in descending priority order: B (10), C (5), A (0 default), so the output is 'BCA'."}

{"answer": "same", "explanation": "Doctrine's UnitOfWork maintains an identity map, so repeated find() calls with the same identifier return the same object instance rather than creating new ones."}

{"answer": 0, "explanation": "When an entity is persisted and then removed before any flush, Doctrine cancels the pending INSERT during flush and issues no DELETE (the row was never in the DB), leaving the table empty."}

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

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

{"answer": "M1M2", "explanation": "The middleware stack processes Trace('M1') first (echoes 'M1'), then passes to Trace('M2') (echoes 'M2'), which passes to the default last handler, so the concatenated output is 'M1M2'."}

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

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

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

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

{"answer": "2, 1", "explanation": "The DataProvider supplies two datasets ([1] and [-1]), so two tests run; the second one fails because -1 > 0 is false."}

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

{"answer": "GET", "explanation": "The -G flag forces curl to use the GET method, appending -d data as a query string to the URL instead of sending a POST body."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, when the client authentication fails (e.g., non-existent client_id), the token endpoint returns the error value 'invalid_client'."}

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

{"answer": 0, "explanation": "The default filter only replaces null/undefined values, so false is kept, and false * 3 equals 0."}

{"answer": "a3", "explanation": "In Twig, the '+' operator has higher precedence than '~', so 'a' ~ 1 + 2 is parsed as 'a' ~ (1+2) = 'a' ~ 3 = 'a3', which renders successfully without throwing an exception."}

{"answer": 0, "explanation": "The value [''] is an array with one element, and Assert\\NotBlank only considers an array blank if it is empty (count === 0), so no violations are found."}

{"answer": "Symfony\\Component\\Form\\Exception\\LogicException", "explanation": "Calling isValid() on a Symfony form that has not been submitted throws a LogicException, which is caught and its class name is echoed."}

{"answer": "same", "explanation": "Symfony DI container services are singletons by default, so calling get('a') twice returns the same stdClass instance."}

{"answer": "%greeting!%", "explanation": "The parameter reference pattern %name% expects a valid parameter name; since '!' is not a valid parameter name character, the reference %greeting!% does not resolve to the defined parameter 'greeting', so the string is left unchanged."}

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

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

{"answer": 2, "explanation": "The Domain class depends on both Application (PlaceOrder) and Infrastructure (Db), but Domain is only allowed to depend on Domain, so both are violations."}

{"answer": 3, "explanation": "The Domain class depends on Application (PlaceOrder) and Infrastructure (Db, Logger), but Domain is only allowed to depend on Domain, giving 3 violations."}

{"answer": "10,15", "explanation": "$a->amount is 10 and $c->amount is 10+5=15, so the concatenated string is '10,15'."}

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

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

{"answer": "yesno", "explanation": "After newLazyGhost the object is uninitialized (prints 'yes'); accessing $o->v triggers the initialization callback, so the second check prints 'no'."}

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

{"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 7.0 (deprecated in 6.1), while AttributeClassLoader (introduced in 6.1) still exists in 8.1."}