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

{"answer": "no", "explanation": "Double-quoted strings support variable interpolation and most escape sequences, while single-quoted strings do not interpolate variables and only recognize \\\\ and \\' escapes, so the difference is in functionality, not just speed."}

{"answer": "yes", "explanation": "The null coalescing operator (??) checks if a value is set and not null using isset() semantics, so it does not trigger warnings or notices for undefined variables."}

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

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

{"answer": "no", "explanation": "The Elvis operator (?:) 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 (.) has the same precedence as addition (+) and subtraction (-); they are all in the same precedence level."}

{"answer": "no", "explanation": "The ** operator in PHP is right-associative, so 2 ** 3 ** 2 is evaluated as 2 ** (3 ** 2) = 512, not (2 ** 3) ** 2 = 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 converts to 0, giving 0 + 3 = 3."}

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

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

{"answer": "no", "explanation": "In PHP 8, when comparing a non-numeric string to an integer with ==, the integer is cast to a string instead, so 'abc' == 0 becomes 'abc' == '0' which is false."}

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

{"answer": 42, "explanation": "PHP's (int) cast reads leading numeric characters from a string and stops at the first non-numeric character, so '42abc' becomes the integer 42."}

{"answer": 10, "explanation": "In PHP, the + operator converts the numeric string '5' to an integer and adds it to 5, resulting in 10."}

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

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

{"answer": "no", "explanation": "strrev() reverses a string byte by byte, which breaks multi-byte UTF-8 characters into garbled sequences."}

{"answer": "yes", "explanation": "str_contains() checks if the haystack string contains the needle string, and 'Hello world' does contain 'world'."}

{"answer": "no", "explanation": "str_pad() can pad a string on the left, right, or both sides using the $pad_type parameter (STR_PAD_LEFT, STR_PAD_RIGHT, 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": "strlen() counts bytes; 'h' (1) + 'é' (2 bytes in UTF-8) + 'llo' (3) = 6 bytes."}

{"answer": "def", "explanation": "substr with a negative start of -3 begins extraction from the 3rd character from the end, yielding 'def'."}

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

{"answer": "yes", "explanation": "Heredoc supports variable interpolation, while nowdoc (with single-quoted delimiter) treats the content as a literal string with no interpolation."}

{"answer": "no", "explanation": "The sort() function re-indexes the array with sequential integer keys, so it does not preserve the original key-to-value association (use asort() for that)."}

{"answer": "yes", "explanation": "PHP automatically casts string keys that are valid integers (like '5') to their integer equivalent when used as array keys."}

{"answer": "no", "explanation": "By default, in_array() uses loose comparison (==); strict comparison (===) is only used when the third parameter 'strict' is explicitly set to true."}

{"answer": "yes", "explanation": "When array_filter() is called without a callback, it removes all falsy values (0, '0', '', null, false, []) from the array."}

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

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

{"answer": 2, "explanation": "The + operator merges arrays with left-side keys taking precedence, so 'a' keeps value 1 and 'b' is added, resulting in 2 elements."}

{"answer": "yes", "explanation": "Prior to PHP 8.1, spreading arrays with string keys in array literals caused an error; PHP 8.1 added support for string keys in the spread operator [...$a, ...$b]."}

{"answer": "no", "explanation": "In PHP 8.0+, named arguments CAN be combined with argument unpacking in a single call, e.g., foo(a: 1, ...$args) is valid syntax."}

{"answer": "no", "explanation": "In PHP, an anonymous function (closure) does not have access to outer-scope variables unless they are explicitly imported via the use keyword."}

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

{"answer": "no", "explanation": "PHP arrow functions (fn) can only contain a single expression after the => and cannot use a curly-brace body with multiple statements."}

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

{"answer": "yes", "explanation": "In PHP, a static closure (declared with the static keyword) explicitly does not bind or capture $this, unlike a non-static closure which automatically captures the $this from its defining scope."}

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

{"answer": "yes", "explanation": "In weak typing mode (default), PHP automatically coerces numeric strings like \"5\" to integers when passed to an int-typed parameter."}

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

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

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

{"answer": "no", "explanation": "In PHP, private properties are only accessible within the class where they are declared and are not accessible in a subclass."}

{"answer": "class@anonymous", "explanation": "get_class() on an anonymous class returns a name in the form 'class@anonymous' followed by a NUL byte and the file path/line number; the part before the NUL byte is 'class@anonymous'."}

{"answer": "yes", "explanation": "Private methods in PHP are not inherited and are not part of the inheritance contract, so a child class is free to declare a method with the same name and any visibility without conflict."}

{"answer": "no", "explanation": "__get() is called for any inaccessible property, including protected and private ones, not just non-existent ones."}

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP throws an Error (not an Exception), as it is a language-level violation caught at runtime."}

{"answer": "yes", "explanation": "PHP interfaces can declare constants (always public), which can be accessed via the interface name."}

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

{"answer": "no", "explanation": "In PHP, interfaces can only declare public instance methods; static methods are not allowed in interface declarations."}

{"answer": "no", "explanation": "PHP's instanceof operator checks both class inheritance and interface implementation, not just class inheritance."}

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

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared as public or protected; a protected abstract method requires the child class to implement it but does not expose it publicly."}

{"answer": 3, "explanation": "The enum Foo defines three cases (A, B, C), so Foo::cases() returns an array containing 3 elements."}

{"answer": "yes", "explanation": "Since PHP 8.2, traits are allowed to declare constants in addition to methods and properties."}

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

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

{"answer": "no", "explanation": "The @ operator suppresses error messages (warnings, notices, etc.) but has no effect on exceptions, which must be handled with try/catch."}

{"answer": "DivisionByZeroError", "explanation": "intdiv() with a divisor of zero throws a DivisionByZeroError, which extends ArithmeticError extends Error."}

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

{"answer": "no", "explanation": "An exception thrown in a finally block actually overrides any exception from the try block, so it does have an effect on the final outcome."}

{"answer": "yes", "explanation": "In PHP, casting any object to boolean always yields true, as objects are inherently truthy."}

{"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 only creates a local alias for the fully-qualified class name; the class file is actually loaded (via the autoloader) only when the class is first referenced (e.g., instantiated or a static member accessed)."}

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

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps the remaining namespace parts (Controller\\Api\\UserController) to subdirectories and the class name to the filename under the base directory src/."}

{"answer": "yes", "explanation": "Composer's vendor/autoload.php ultimately calls spl_autoload_register() (via autoload_real.php) to register the autoloader."}

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

{"answer": "no", "explanation": "An unqualified class name in a new expression is resolved relative to the current namespace first (falling back to global only if not found there), not always from the global root."}

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

{"answer": "yes", "explanation": "In PHP, a use statement is allowed inside a function body, in which case the alias/import only applies within that function's scope."}

{"answer": "yes", "explanation": "In PHP, arrays are value types, so assignment creates a copy (with copy-on-write optimization); passing by reference requires the explicit & operator."}

{"answer": 2, "explanation": "PHP arrays use copy-on-write semantics, so assigning $b = $a creates an independent copy; modifying $b does not affect $a, which still has 2 elements."}

{"answer": "yes", "explanation": "In PHP, variables have function-level scope by default, so global variables must be accessed via the global keyword, $GLOBALS superglobal, or by being passed as parameters to be usable inside a function."}

{"answer": "no", "explanation": "$GLOBALS['x'] is a direct reference to the global variable, so unset($GLOBALS['x']) removes it from the global scope entirely, not just locally."}

{"answer": 6, "explanation": "The function parameter is passed by reference (&$x), so incrementing $x directly modifies $n from 5 to 6."}

{"answer": "no", "explanation": "In PHP, foreach iterates over the array's state at the start of the loop; modifications to the array (adding/removing elements) inside the loop body are not reflected 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 through all others."}

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

{"answer": "yes", "explanation": "In PHP 7.0+, a generator can return a value using `return`, and that value is accessible via the Generator object's `getReturn()` method after the generator is exhausted."}

{"answer": "no", "explanation": "PHP generators are one-shot iterators; once fully consumed, they cannot be rewound and traversed again."}

{"answer": "no", "explanation": "PHP does not have a 'yield from' construct; that is a Python 3 feature. PHP generators only use 'yield' without delegation syntax."}

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

{"answer": 3, "explanation": "The generator yields from [1,2,3], producing 3 elements, and iterator_to_array converts them into an array of 3 elements, so count returns 3."}

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

{"answer": "yes", "explanation": "ArrayIterator is an SPL class that wraps an array and implements the Iterator (among other) interfaces, enabling traversal via foreach or Iterator methods."}

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

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

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT uses bcrypt (or Argon2id in PHP 8.4+), not md5."}

{"answer": "yes", "explanation": "password_verify() returns true when the provided password matches the hash generated from the same password."}

{"answer": "no", "explanation": "strip_tags() only removes HTML and PHP tags; SQL injection must be prevented with prepared statements/parameterized queries."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID, which is the standard defense against session fixation attacks, typically called after a user's privilege level changes (e.g., login)."}

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

{"answer": "yes", "explanation": "session_destroy() only removes the session data on the server; the session cookie in the browser must be explicitly cleared with setcookie() using a past expiration date."}

{"answer": "no", "explanation": "The $_SESSION superglobal is only populated after session_start() has been called in the current request; without it, $_SESSION is either undefined or empty."}

{"answer": "no", "explanation": "There is no built-in array_find() function in any PHP version; PHP offers array_search() and array_filter() instead."}

{"answer": "yes", "explanation": "Property hooks (inline get/set accessors in property declarations) were indeed a major feature introduced in PHP 8.4."}

{"answer": "no", "explanation": "PHP does not have an 'asymmetric visibility' feature with the syntax 'public private(set) string $name'; that resembles C# property access modifiers, not PHP. PHP 8.4 introduced property hooks, but not this construct."}

{"answer": "not a real PHP attribute", "explanation": "PHP does not have a built-in #[\\NoDiscard] attribute; it is not part of any PHP version's standard library."}

{"answer": "none", "explanation": "PHP has never introduced a pipe operator (|>) in any released version; it is not a feature of the PHP language."}

{"answer": "no", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) was proposed in RFCs but was never implemented in any released version of PHP."}

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

{"answer": "8.5", "explanation": "The RFC Partial Function Application v2 was targeted for adoption in PHP 8.5."}

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

{"answer": "no", "explanation": "There is no adopted RFC for 'Context Managers v2' in PHP; this feature does not exist in any released PHP version."}

{"answer": "no", "explanation": "There is no known PHP RFC titled 'Bound-Erased Generic Types' that was declined in 2026; this appears to be a fabricated or misstated RFC."}

{"answer": "no", "explanation": "As of 2026-11-07, no RFC has been accepted in PHP to enable Zend Thread Safety (ZTS) by default; PHP's default build remains non-thread-safe (NTS)."}

{"answer": "yes", "explanation": "PHP has never implemented true generics (parameterized types) as of any released or planned version up to 8.5."}

{"answer": "yes", "explanation": "PHP follows an annual release cycle in November, so by 2026-11-07 PHP 8.5 (released Nov 2025) would be the latest stable, with PHP 8.6's GA scheduled for 2026-11-19."}

{"answer": "yes", "explanation": "PHP 6 was a planned major revision that was never released; the PHP team skipped directly from PHP 5.6 to PHP 7.0."}

{"answer": "no", "explanation": "The RFC proposing a built-in #[\\Deprecated] attribute for PHP core was not adopted; no such attribute exists in any released PHP version as of 8.4."}

{"answer": "yes", "explanation": "In both clean and onion architecture, the dependency rule dictates that dependencies must point inward toward the center (domain core), and inner layers have no knowledge of outer layers."}

{"answer": "yes", "explanation": "In clean/DDD architecture, domain entities are pure PHP classes that must not depend on ORM (Doctrine) or web framework (Symfony) specifics, only on the language itself and standard library."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (interface) layer, not the business-logic layer; they handle HTTP requests and view rendering while delegating business logic to use cases in the application layer."}

{"answer": "domain", "explanation": "In onion architecture, the innermost layer (center) contains the core domain entities and business logic, which are independent of any frameworks or infrastructure."}

{"answer": "yes", "explanation": "Tools like deptrac (Dependency Tracker) are designed to enforce layer boundaries by analyzing inter-layer dependencies and failing the build when a forbidden call is detected."}

{"answer": "no", "explanation": "In Clean/Hexagonal Architecture, use cases (interactors) must remain decoupled from framework details like HTTP requests or EntityManagers; they should accept and return simple domain objects or DTOs to stay testable, reusable, and independent of infrastructure."}

{"answer": "Repository", "explanation": "A Repository is the component that provides a collection of aggregates/entities while abstracting the underlying storage mechanism behind an interface."}

{"answer": "yes", "explanation": "In Clean Architecture, the domain and use cases depend on abstractions (interfaces/ports), so changing the database implementation only affects the outer adapter layer."}

{"answer": "no", "explanation": "In DDD, an aggregate is a domain-level cluster of related entities and value objects with a single aggregate root enforcing invariants; it is not a database table, and the mapping between aggregates and tables is a persistence concern."}

{"answer": "yes", "explanation": "A Value Object is defined by its field values rather than a unique identity, and it is immutable once created."}

{"answer": "Aggregate Root", "explanation": "In DDD, the Aggregate Root is the single external entry point of an aggregate through which all external interactions and changes must pass."}

{"answer": "yes", "explanation": "In DDD, a repository is defined per aggregate root, ensuring all entities within the aggregate are accessed and modified through a single consistency boundary."}

{"answer": "yes", "explanation": "Ubiquitous Language in Domain-Driven Design is indeed 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 is the conceptual boundary within which a model's language is internally consistent, and outside of which the same terms can carry different meanings in other models or contexts."}

{"answer": "no", "explanation": "DDD advocates for rich domain models where business logic is encapsulated within entities/aggregates, not in separate services with anemic getter/setter-only objects."}

{"answer": "yes", "explanation": "In DDD, a Bounded Context explicitly defines a boundary within which a domain model is valid, and the same real-world concept (e.g., Customer) can be represented as entirely different classes with different attributes and behaviors in different contexts."}

{"answer": "yes", "explanation": "Symfony's DI container stores service definitions and only instantiates the actual object on first retrieval, which is the default lazy behavior."}

{"answer": "debug:router", "explanation": "In Symfony, the command 'php bin/console debug:router' lists all registered routes (replacing the older 'router:list' command)."}

{"answer": "no", "explanation": "The whole purpose of autowiring is to automatically resolve and inject dependencies based on type hints, eliminating the need to manually declare every service in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles each template into a PHP class (extending Twig\\Template) and stores the compiled file in a cache directory, reusing it across subsequent requests as long as the source template hasn't changed."}

{"answer": "yes", "explanation": "In the Symfony dev environment, the container is compiled once and cached; on each request Symfony only checks whether any tracked (source) files have changed and rebuilds only if they have, rather than recompiling on every request."}

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

{"answer": "no", "explanation": "Symfony controller methods must be public; the framework uses reflection to invoke them and cannot call private or protected methods."}

{"answer": "no", "explanation": "In Symfony's event system, subscribers and listeners are both dispatched based on priority and registration order; the EventSubscriberInterface does not grant any inherent priority over regular listeners."}

{"answer": "yes", "explanation": "Symfony 6.0 removed the legacy guard authentication system, making the new authenticator (AuthenticatorInterface) the sole authentication mechanism."}

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

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

{"answer": "yes", "explanation": "Symfony 7+ uses PHP attributes (e.g. #[Assert\\NotBlank]) for validation and has removed support for the old Doctrine annotations syntax (@Assert\\NotBlank)."}

{"answer": "yes", "explanation": "Symfony enables CSRF protection for forms by default (framework.form.csrf_protection defaults to true), automatically generating and validating a token on each form submission."}

{"answer": "yes", "explanation": "Symfony always re-validates form data server-side using its Constraint system, regardless of whether HTML5 client-side validation already passed, because client-side checks are only a UX convenience and cannot be trusted for security."}

{"answer": "make:form", "explanation": "The Symfony Maker Bundle command 'make:form' generates a FormType class for creating forms in Symfony."}

{"answer": "no", "explanation": "Symfony stores a security token (e.g., session ID or JWT) in the session, not the user's password; passwords are stored hashed in the database."}

{"answer": "yes", "explanation": "In modern Symfony, bundle/topic configurations are conventionally placed in config/packages/ with one file per bundle or topic (e.g., framework.yaml, doctrine.yaml)."}

{"answer": "yes", "explanation": "This is a common best practice: the .env file holds safe dev defaults and is committed, while .env.local holds real secrets and is excluded via .gitignore."}

{"answer": "debug:container", "explanation": "The Symfony command `debug:container` (or `container:debug` in older versions) lists all registered services and their aliases in the DI container."}

{"answer": "no", "explanation": "The Symfony container is compiled (parameters baked into the generated class), so calling setParameter() at runtime does not meaningfully alter already-instantiated services; the container is intended to be immutable after compilation."}

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

{"answer": "no", "explanation": "Many bundles work out of the box with default settings and do not require a configuration file in config/packages; you only need one if you want to customize the bundle's defaults."}

{"answer": "yes", "explanation": "In Symfony, environment variables are referenced in configuration files (including services.yaml) using the %env(VAR_NAME)% syntax."}

{"answer": "APP_DEBUG", "explanation": "In Symfony, the APP_DEBUG environment variable (set in the .env file) controls debug mode, enabling the profiler and Twig debugging features."}

{"answer": "no", "explanation": "Symfony Messenger allows multiple handlers for a single message; they are executed in order of priority, enabling event-driven, decoupled processing."}

{"answer": "no", "explanation": "The sync transport processes the message immediately in the current process without queuing it for a separate worker; only async transports (e.g., AMQP, Redis, Doctrine) enqueue the message for a worker to consume later."}

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

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

{"answer": "no", "explanation": "By default, Symfony Messenger uses the PhpSerializer (PHP's serialize()/unserialize()), not JSON; a separate JsonSerializer must be configured explicitly."}

{"answer": "yes", "explanation": "Symfony Scheduler is designed to create scheduled messages and dispatch them through the Messenger component at defined intervals."}

{"answer": "doctrine", "explanation": "Symfony Messenger's 'doctrine://default' transport persists messages into database tables managed by Doctrine."}

{"answer": "yes", "explanation": "The Messenger (Symfony/Laravel) pipeline supports registering custom middleware and ordering them before or after the built-in middleware in the chain."}

{"answer": "no", "explanation": "Symfony major releases do not follow a fixed two-year cycle; they have appeared at irregular intervals (e.g., Symfony 2.0 in 2011, 3.0 in 2016, 4.0 in 2017, 5.0 in 2020, 6.0 in 2022, 7.0 in 2023), while minor releases do typically ship in May and November."}

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

{"answer": "no", "explanation": "Symfony 7.0 removed docblock annotation support entirely; only PHP attributes are supported for validation and routing."}

{"answer": "yes", "explanation": "Symfony's AssetMapper handles JS and CSS assets server-side without Node.js or Webpack, using importmap.php to define and resolve JavaScript imports."}

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release, following the same pattern as 4.4 and 5.4, receiving extended bug-fix and security support."}

{"answer": "no", "explanation": "In Symfony, deprecated features are removed in the next major version; that is precisely the purpose of a major release (semver allows breaking changes)."}

{"answer": "yes", "explanation": "Symfony includes UPGRADE-*.md files in its repository for every major (and minor) release, documenting deprecations, removals, and breaking changes."}

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

{"answer": "no", "explanation": "Following Symfony's typical release cadence (minor versions roughly every 6 months), Symfony 8.2 would not be expected until well after November 2026 at the earliest, making it false that it has already been released by that date."}

{"answer": "no", "explanation": "Following Symfony's six-month cycle (major in May, minor in November), Symfony 8.0 would land in May 2026 and 8.1 in November 2026, not 8.2."}

{"answer": "8.2", "explanation": "Symfony follows a major.minor versioning scheme, so the version immediately following 8.1 is 8.2."}

{"answer": "no", "explanation": "Symfony 8.2 is a minor release (not a major one like 8.0), and minor releases maintain backward compatibility without requiring a rewrite."}

{"answer": "yes", "explanation": "PHP guarantees backward compatibility within the same major version series (8.x), so minor updates like 8.1 → 8.2 add features without breaking existing code."}

{"answer": "8.4", "explanation": "Symfony follows a pattern where each major branch ends with an x.4 LTS release, so the last minor version of the 8.x branch before 9.0 is 8.4."}

{"answer": "no", "explanation": "Symfony 8.2 is not a released version; as of current knowledge the latest major line is Symfony 7.x, making this statement false."}

{"answer": "yes", "explanation": "Symfony's deprecation policy states that deprecations introduced in a given major version (8.x) are only removed starting from the next major version (9.0), not before."}

{"answer": "no", "explanation": "Twig deliberately restricts templates to its own expression language (variables, filters, functions, operators) and does not allow calling arbitrary PHP code directly inside {{ }}."}

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

{"answer": "yes", "explanation": "The Twig |e (escape) filter defaults to escaping a string for safe output in an HTML context."}

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

{"answer": "yes", "explanation": "In Twig, the |raw filter marks a value as safe and outputs it without auto-escaping."}

{"answer": "yes", "explanation": "In Twig, double curly braces {{ }} echo an expression's value, while {% %} is used for control-structure 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 myVar = 'value' %}, so values do not only come from the controller."}

{"answer": "dump", "explanation": "Twig's dump() function (from the Twig\\Extension\\DebugExtension) outputs the debug structure of a variable such as an array or object."}

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JS library providing pre-built UI components and utilities, not a Single Page Application framework like React, Angular, or Vue."}

{"answer": "container", "explanation": "The .container class in Bootstrap provides a responsive fixed-width container that changes its max-width at each breakpoint (e.g., 540px, 720px, 960px, 1140px, 1320px)."}

{"answer": "no", "explanation": "The Bootstrap grid uses Flexbox (Bootstrap 4+) or CSS Grid, and splits a row into 12 columns, not 16."}

{"answer": "yes", "explanation": "In Bootstrap 5, the five named breakpoint infixes are indeed sm, md, lg, xl, and xxl."}

{"answer": "no", "explanation": "Bootstrap spacing utilities use increments of $spacer/4 (e.g., .mt-1 = $spacer*0.25, .mt-2 = $spacer*0.5), not whole multiples of $spacer."}

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

{"answer": "yes", "explanation": "Bootstrap 5 removed the jQuery dependency entirely; all its interactive components (modals, dropdowns, tooltips, etc.) are powered by vanilla JavaScript."}

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

{"answer": "no", "explanation": "Doctrine ORM does not auto-create tables at runtime; you must explicitly run schema/migration commands (e.g., doctrine:migrations:migrate or doctrine:schema:create) to create or update database tables."}

{"answer": "persist", "explanation": "EntityManager::persist() marks a new entity as managed and schedules it for insertion, but no SQL is executed until flush() is called."}

{"answer": "no", "explanation": "In Doctrine ORM 3, the EntityManager::merge() method was removed; it existed in ORM 2 but is no longer part of the EntityManager API in ORM 3."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) operates on entities and their fields at the object level, abstracting away the underlying table and column structure."}

{"answer": "null", "explanation": "In PHP (e.g., Doctrine ORM), the find() method returns null when no entity with the given ID exists."}

{"answer": "yes", "explanation": "DoctrineBundle registers an event subscriber that listens to kernel.response and automatically calls flush() on the entity manager at the end of each request."}

{"answer": "yes", "explanation": "In Doctrine ORM, the Unit of Work performs dirty checking on managed entities, so calling flush() is sufficient to commit property changes without needing to call persist() again."}

{"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's key benefit is that readers and writers do NOT block each other; readers see a consistent snapshot while writers create new row versions concurrently."}

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

{"answer": "no", "explanation": "SERIAL creates a separate sequence object plus a column default (nextval), while GENERATED AS IDENTITY is an internally managed identity column with no separate sequence object; they are similar in effect but different mechanisms."}

{"answer": "no", "explanation": "In PostgreSQL, a UNIQUE constraint treats NULL values as distinct, so it allows multiple rows with NULL in the column by default."}

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

{"answer": "no", "explanation": "Plain VACUUM only marks dead tuple space as reusable within the table file; it does not shrink the file or return space to the OS (that requires VACUUM FULL)."}

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

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

{"answer": "yes", "explanation": "PostgreSQL operates in autocommit mode by default, meaning each individual SQL statement is implicitly wrapped in its own transaction and committed immediately unless an explicit BEGIN/COMMIT is used."}

{"answer": "COMMIT", "explanation": "The COMMIT SQL command finalizes a transaction, permanently saving all changes made within it to the database."}

{"answer": "yes", "explanation": "Indexes are used by the storage engine to locate rows for SELECT, UPDATE, and DELETE operations, so any query that filters on an indexed column benefits from the index."}

{"answer": "yes", "explanation": "PostgreSQL supports SAVEPOINT to set a restore point within a transaction, allowing a partial rollback with ROLLBACK TO SAVEPOINT without aborting the entire transaction."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query to collect real timing and row-count statistics; only plain EXPLAIN shows the plan without execution."}

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

{"answer": "yes", "explanation": "A partial index (e.g., in PostgreSQL) stores only the rows that meet the WHERE condition, reducing index size and improving performance for targeted queries."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE via Serializable Snapshot Isolation (SSI), which detects conflicts at commit time rather than by locking rows read during the transaction."}

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

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

{"answer": "yes", "explanation": "The HTTP specification (RFC 7231) explicitly lists DELETE as an idempotent method, meaning repeated identical requests produce the same end state (the resource is removed)."}

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

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests is specifically designed to inform a client that it has exceeded the rate limit defined by the server."}

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

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not idempotent, while PUT (RFC 7231) is required to be idempotent."}

{"answer": "no", "explanation": "Using == is vulnerable to timing attacks; PHP provides hash_equals() for constant-time comparison of hashes."}

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

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to define and enforce CSP policies for a web resource."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol (granting access to resources), not an authentication protocol; the access token grants scoped permissions rather than identifying the user, and user identity is handled by layers like OpenID Connect."}

{"answer": "no", "explanation": "XSS is primarily prevented by encoding/escaping output when rendering in the browser, not by input validation before storing data; valid input can still be reflected unsafely if output encoding is missing."}

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

{"answer": "yes", "explanation": "In OAuth 2.0, refresh tokens are designed to have a longer lifetime than access tokens and are specifically used to obtain new access tokens without re-authenticating the user."}

{"answer": "no", "explanation": "A salt is not 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 be discovered and executed as test cases."}

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

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

{"answer": "expectException", "explanation": "PHPUnit's expectException() method declares that a test expects an exception of the given class to be thrown."}

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

{"answer": "yes", "explanation": "PHPUnit 10+ recommends using the #[DataProvider] attribute for data-driven tests, and the @dataProvider docblock annotation is deprecated."}

{"answer": "no", "explanation": "PHPUnit supports test dependencies via the @depends annotation (or #[Depends] attribute), allowing one test to rely on and even receive the return value of another test."}

{"answer": "--order-by=random", "explanation": "PHPUnit uses the --order-by=random command-line option to execute test methods in a random order."}

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

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

{"answer": "true", "explanation": "In PHP 8, both '1e1' and '10' are numeric strings, so they are compared numerically: 1e1 (which equals 10) == 10 is true."}

{"answer": "other", "explanation": "In PHP 8, 'a' == 0 is false (the integer is cast to string, comparing '0' with 'a'), so the switch falls through to the default case."}

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

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

{"answer": "k,n,m", "explanation": "Array union (+) keeps keys from $a first, then adds non-overlapping keys from $b, so array_keys gives ['k','n','m'] which implodes to 'k,n,m'."}

{"answer": "yxz", "explanation": "Sorting by the third element (index 2) gives order [2,'y',1], [1,'x',2], [3,'z',2']; extracting column 1 yields 'y','x','z'; implode produces 'yxz'."}

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

{"answer": "Error", "explanation": "$p->g(...) is a syntax error because the spread operator ... requires an array variable after it; the code fails to parse and produces no output."}

{"answer": "B", "explanation": "static::class uses late static binding, returning the name of the class the method was called on (B), not the class where it's defined (A)."}

{"answer": 10, "explanation": "The set hook multiplies the assigned value by 2 (5*2=10) and stores it in the backing store; reading the property with no get hook returns the backing store value of 10."}

{"answer": "BA", "explanation": "TB::f insteadof TA makes f() return 'B', and TA::f as g renames TA's f to g() returning 'A', so concatenation yields '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 from the try block, so the function returns 2."}

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

{"answer": "App\\Foo|Baz", "explanation": "Baz::class resolves to the aliased fully-qualified name App\\Foo, while \\Baz::class refers to the global-namespace class Baz."}

{"answer": "noyes", "explanation": "class_exists('Foo') looks for a global class Foo (not found → 'no'), while class_exists('Ns\\Foo') finds the class Foo in namespace Ns (found → 'yes'), concatenated as 'noyes'."}

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

{"answer": 3, "explanation": "Static variables in PHP methods are shared per class definition, not per instance, so both A and B (inheriting from A) share the same static $n, which increments to 3 after three calls."}

{"answer": "", "explanation": "The generator is still paused at its first yield (not yet completed), so getReturn() returns null, which echoes as an empty string."}

{"answer": "1,2,ok", "explanation": "yield from delegates to inner() which yields 1 and 2, then its return value 'ok' is captured in $r and yielded next, so implode produces '1,2,ok'."}

{"answer": "noyes", "explanation": "The first check compares the hash's cost (4) to 4, so no rehash is needed ('no'); the second check compares cost 4 to 5, so a rehash is needed ('yes')."}

{"answer": "strict-out", "explanation": "In PHP 8.5, E_STRICT (2048) was removed/deprecated, so E_ALL no longer includes the 2048 bit, making (E_ALL & 2048) === 0 true."}

{"answer": "mapped", "explanation": "Symfony normalizes HTTP_X_TOKEN to the header name x-token, so get('X-Token') correctly returns 'abc'."}

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

{"answer": "same", "explanation": "After flush, the entity is in the identity map, so both find() calls return the exact same managed object reference, making their spl_object_id values equal."}

{"answer": 0, "explanation": "Persisting then removing a new (not-yet-flushed) entity before flush causes Doctrine to skip the INSERT entirely, so the table remains empty."}

{"answer": 1, "explanation": "COUNT(x) counts only non-NULL values of column x; there is one non-NULL row (x=1) and one NULL row, 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": "Each middleware in the stack echoes its tag in order (M1, then M2) before passing to the next handler in the chain."}

{"answer": 11, "explanation": "The HandleMessageMiddleware calls all handlers registered for Ping (both $d1 adding 1 and $d2 adding 10), so $n = 0 + 1 + 10 = 11."}

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

{"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 succeed and the count is 2."}

{"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 data provider yields two cases (1 and -1); x>0 passes for 1 but fails for -1, giving 2 ran and 1 failed."}

{"answer": "POST", "explanation": "The -d (or --data) flag in curl automatically switches the HTTP method from GET to POST."}

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

{"answer": "invalid_client", "explanation": "RFC 6749 §5.2 specifies that client authentication failure (e.g., non-existent client_id) results in 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 (the portion after the '#' symbol) of the redirect URI, not in the query string."}

{"answer": 6, "explanation": "In Twig, false is considered 'empty', so the default filter returns 2, and 2 * 3 equals 6."}

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

{"answer": 1, "explanation": "The array [''] contains one empty string which violates the NotBlank constraint, resulting in 1 violation."}

{"answer": "invalid", "explanation": "A Symfony form that has not been submitted is not synchronized, so isValid() returns false."}

{"answer": "same", "explanation": "Symfony's DI container caches service instances by default, so two calls to get('a') return the same object, making spl_object_id equal."}

{"answer": "hi Bob!", "explanation": "During compile, parameter references are resolved recursively: %name% → Bob, %greeting% → hi Bob, and %greeting!% → hi Bob!"}

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

{"answer": "text-danger", "explanation": "In Bootstrap 5.3's generated CSS, text-danger is defined after text-primary, so it wins the cascade for the same element."}

{"answer": 2, "explanation": "The Domain class depends on Application (PlaceOrder) and Infrastructure (Db), but the rule states Domain may only depend on Domain, resulting in 2 violations."}

{"answer": 3, "explanation": "The Domain class references PlaceOrder (Application), Db (Infrastructure), and Logger (Infrastructure), each being a forbidden dependency since Domain may only depend on Domain, giving 3 violations."}

{"answer": "10,15", "explanation": "$a->amount is still 10 (objects are immutable here), and $c->amount is 10+5=15, so the echo produces the string '10,15'."}

{"answer": 1, "explanation": "The remove() call throws a DomainException because count is 1, the exception is caught, so the item is never unset, and count() still returns 1."}

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

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

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

{"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 7.0 (deprecated since 5.3), so it doesn't exist in 8.1; AttributeClassLoader remains the active class, giving 'no' then 'yes'."}