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

{"answer":"no","explanation":"Double-quoted strings support variable interpolation and additional escape sequences (e.g. \\n, \\t), while single-quoted strings only interpret \\\\ and \\' — the difference is functional, not just speed."}

{"answer": "yes", "explanation": "The ?? operator is defined as a shorthand for isset($var) ? $var : default, so it does not raise warnings for undefined variables."}

{"answer": "ab", "explanation": "PHP's echo statement accepts multiple comma-separated arguments and prints them concatenated together."}

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

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

{"answer": "yes", "explanation": "In PHP, the concatenation operator (.) has lower precedence than + and -, so expressions like 'a' . 1 + 2 are parsed as 'a' . (1 + 2)."}

{"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 addition (+), so it parses as ('sum: '.2)+3, which becomes 'sum: 2'+3; the non-numeric string casts to 0, giving 0+3=3."}

{"answer": "no", "explanation": "With ===, arrays must have the same key-value pairs in the same order and matching types."}

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

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

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

{"answer": 42, "explanation": "PHP casts a string to int by reading numeric characters from the start and stopping at the first non-numeric character, so '42abc' becomes 42."}

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

{"answer": "no", "explanation": "When false is cast to a string in PHP, it becomes an empty string \"\", not \"0\"."}

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

{"answer":"no","explanation":"strrev() reverses bytes, not characters, so multi-byte UTF-8 characters get split and produce invalid output."}

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

{"answer": "no", "explanation": "str_pad() can pad on the right, left, or both sides using 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": "strlen() counts bytes; 'é' is 2 bytes in UTF-8, plus 4 single-byte ASCII characters = 6 bytes total."}

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

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

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

{"answer": "no", "explanation": "sort() re-indexes the array with numeric keys, while asort() is the function that preserves key-to-value associations."}

{"answer": "yes", "explanation": "In PHP, numeric string keys in arrays are automatically cast to integers, so '5' and 5 refer to the same key."}

{"answer": "no", "explanation": "in_array() uses loose comparison (==) by default; strict comparison requires the third parameter to be set to true."}

{"answer": "yes", "explanation": "When array_filter() is called without a callback, it removes all elements that evaluate to falsy (0, '', null, false, '0')."}

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

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

{"answer": 2, "explanation": "The + operator keeps left array values for duplicate keys and only adds new keys from the right, resulting in ['a' => 1, 'b' => 2]."}

{"answer": "yes", "explanation": "PHP 8.1 introduced the array spread operator which supports both integer and string keys, preserving them in the resulting array."}

{"answer": "no", "explanation": "In PHP 8.0+, named arguments can be combined with argument unpacking in the same call, e.g. foo(...$args, c: 3)."}

{"answer": "no", "explanation": "In PHP, closures do not automatically inherit variables from the outer scope; they must be explicitly imported using the 'use' keyword."}

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

{"answer": "no", "explanation": "An arrow function (fn) body must be a single expression, not multiple statements in curly braces."}

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

{"answer": "yes", "explanation": "In PHP, a static closure explicitly does not bind $this, unlike a regular closure which captures $this automatically when created within an object context."}

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

{"answer": "yes", "explanation": "In weak typing mode (default), PHP performs type coercion, so the string '5' is automatically converted to the integer 5 when passed to an int parameter."}

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

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

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

{"answer": "no", "explanation": "Private properties are only accessible within the class where they are declared, not in subclasses."}

```json ⏎ {"answer": "class@anonymous", "explanation": "In PHP, anonymous classes created with 'new class {}' get a generated name in the format 'class@anonymous\\0/path/to/file.php:line', so the part before the NUL byte is 'class@anonymous'."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, private methods are not inherited and are invisible to child classes, so a child can declare a method with the same name and any visibility without conflict."}

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

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP throws a ReadOnlyProperty error, which extends the Error class."}

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

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

{"answer": "no", "explanation": "In PHP, interface methods must be abstract and non-static; declaring a static method in an interface results in a fatal error."}

{"answer":"no","explanation":"The instanceof operator in PHP returns true if the object is an instance of a class OR implements an interface, so it does not ignore interfaces."}

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

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared as public or protected, but not private."}

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

{"answer": "yes", "explanation": "Traits in PHP can declare constants, which are then available to any class that uses the trait."}

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

{"answer": "no", "explanation": "TypeError extends Error, not Exception; both Exception and Error are separate branches under the Throwable interface."}

{"answer": "no", "explanation": "The @ operator only suppresses errors (warnings, notices, etc.), not exceptions; exceptions must still be caught with try/catch."}

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

{"answer": "no", "explanation": "The finally block runs regardless of whether an exception was thrown, caught, or not — it always executes after the try/catch blocks."}

{"answer": "no", "explanation": "An exception thrown in a finally block will replace (suppress) any exception from the try/catch block, so it does have an effect on the result."}

{"answer": "yes", "explanation": "In PHP, any object cast to bool always results in true, because objects are inherently truthy."}

{"answer": "yes", "explanation": "Shutdown functions registered with register_shutdown_function() are executed at the end of the request cycle, which includes when exit or die is called."}

{"answer": "no", "explanation": "The use statement only creates a local alias for the FQCN; the class file is actually loaded (via autoloading) only when the class is first used at runtime."}

{"answer": "function", "explanation": "In PHP, to import a function you use 'use function' (e.g., use function Foo\\bar();), while 'use const' is for importing constants."}

```json ⏎ {"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps the remaining sub-namespaces (Controller\\Api) to subdirectories and the class name to the filename, appended to the base path src/."} ⏎ ```

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

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

```json ⏎ {"answer": "no", "explanation": "An unqualified class name in 'new' is resolved relative to the current namespace, not from the global root; only a leading backslash forces global resolution."} ⏎ ```

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

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

{"answer": "yes", "explanation": "In PHP, arrays are value types and are copied on assignment by default; you must explicitly use the & operator to pass or assign by reference."}

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

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

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

{"answer": 6, "explanation": "The parameter is passed by reference (&$x), so incrementing $x inside the function also increments $n, making it 6."}

```json ⏎ {"answer": "no", "explanation": "A foreach by value iterates over a copy of the array, so modifications to the original array inside the loop are not reflected in the current pass."} ⏎ ```

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

{"answer": "no", "explanation": "In PHP, boolean keys are cast to integers: true becomes 1 and false becomes 0, so the key is stored as an integer, not a boolean."}

{"answer": "yes", "explanation": "Since PHP 7.0, generators support return with a value, accessible via $gen->getReturn()."}

{"answer": "no", "explanation": "Once a generator is fully consumed and closed, calling rewind() on it throws a RuntimeException; generators are one-shot iterators."}

{"answer": "no", "explanation": "PHP has 'yield' but no 'yield from' construct; 'yield from' is a Python feature."}

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

{"answer": 3, "explanation": "yield from [1, 2, 3] produces three values, and count() on the resulting array returns 3."}

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

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

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

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

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT is Argon2id (or Argon2/bcrypt as fallback), not md5."}

{"answer": "yes", "explanation": "password_verify() returns true when the plaintext password matches the hash generated by password_hash()."}

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags from a string but does not protect against SQL injection; prepared statements or parameterized queries are needed for that."}

{"answer": "yes", "explanation": "session_regenerate_id() generates a new session ID, which is a standard defense against session fixation attacks, typically called after login."}

{"answer": "php_sapi_name()", "explanation": "php_sapi_name() is the built-in function that returns the current SAPI module name, such as 'cli' for command-line usage."}

{"answer": "yes", "explanation": "session_destroy() only removes the session data on the server; the session cookie in the browser must be deleted separately (e.g., with setcookie() setting an expiration in the past)."}

{"answer": "no", "explanation": "The $_SESSION superglobal is only populated with session data after session_start() has been called."}

{"answer": "8.4", "explanation": "The array_find() function was introduced in PHP 8.4 as part of new array helper functions."}

{"answer": "yes", "explanation": "Property hooks, allowing custom get/set logic directly in the property declaration, were introduced in PHP 8.4."}

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

{"answer": "not a real attribute", "explanation": "There is no built-in #[\\NoDiscard] attribute in PHP; it is not part of any released version."}

```json ⏎ {"answer": 8.4, "explanation": "The pipe operator |> was introduced in PHP 8.4 as a new language feature."} ⏎ ```

{"answer": "no", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) has not been implemented in any released PHP version; it remains a proposed/unaccepted feature."}

```json ⏎ {"answer": "8.4", "explanation": "The array_first() and array_last() functions were introduced in PHP 8.4."} ⏎ ```

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

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

{"answer":"no","explanation":"There is no widely known 'RFC Context Managers v2' adopted in PHP; the term 'context managers' is more closely associated with Python's 'with' statement."}

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

```json ⏎ {"answer": "no", "explanation": "As of 2026, PHP has not accepted an RFC to make Zend Thread Safety (ZTS) the default build mode; NTS remains the default."} ⏎ ```

{"answer": "yes", "explanation": "PHP has never included built-in generics (parameterized types), and no accepted RFC adds them by PHP 8.5."}

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

{"answer": "yes", "explanation": "PHP 6 was in development for years but was skipped; after PHP 5.6, the next major release was PHP 7.0 in December 2015."}

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

{"answer": "yes", "explanation": "The dependency rule in both Clean and Onion architecture states that dependencies must always point inward, meaning inner layers (domain) have no knowledge of outer layers (frameworks, UI, DB)."}

{"answer": "yes", "explanation": "In DDD and clean architecture, domain entities should be pure objects that depend only on the language and standard library, with no coupling to frameworks like Doctrine or Symfony."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (or interface) layer, not the business-logic layer; they merely orchestrate calls to use cases."}

{"answer": "Entity", "explanation": "In onion architecture, the innermost layer contains the core entities (domain model) representing the enterprise business rules."}

{"answer": "yes", "explanation": "Deptrac and similar layer-dependency analyzers enforce architectural rules by failing the build when a forbidden inter-layer dependency is detected."}

{"answer": "no", "explanation": "A use case (interactor) should depend on abstractions and domain entities, not on external details like HTTP requests or EntityManagers, to maintain framework-agnostic and easily testable business logic."}

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

```json ⏎ {"answer": "yes", "explanation": "In Clean Architecture, the domain and use cases depend only on abstract interfaces; the concrete database adapter lives in the outermost (frameworks & drivers) layer, so swapping the DB engine only affects that outer layer."} ⏎ ```

{"answer": "no", "explanation": "An aggregate in DDD is a cluster of domain objects treated as a consistency boundary, not a database table; mapping it to a table is a persistence concern, not part of the definition."}

{"answer": "yes", "explanation": "By definition in DDD, Value Objects are immutable and their equality is determined by their field values, not by reference identity."}

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

{"answer": "yes", "explanation": "In DDD, a repository is defined per aggregate root, managing the entire aggregate as a unit, and internal entities are accessed through the root."}

{"answer": "yes", "explanation": "Ubiquitous Language, a concept from Domain-Driven Design (Eric Evans), is precisely the shared language between developers and domain experts that is used consistently in code, documentation, and conversation."}

{"answer": "paradigm", "explanation": "A paradigm is the boundary within which a model and its language are internally consistent, while outside it the same terms may refer to different models or frameworks."}

{"answer": "no", "explanation": "DDD recommends a rich domain model where entities and value objects encapsulate both state and behavior, not an anemic model with logic pushed into services."}

{"answer": "yes", "explanation": "In DDD, a bounded context defines a boundary where a domain model is consistent; the same real-world concept (e.g., 'Customer') can be modeled as different classes with different attributes in different bounded contexts."}

{"answer": "yes", "explanation": "Symfony DI container services are instantiated lazily by default, meaning they are created only when first requested via get() rather than at container build time."}

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

{"answer": "no", "explanation": "The whole point of autowiring is that Symfony automatically resolves and injects dependencies based on type hints, so you do not need to manually declare every service."}

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes (extending Twig\\Template) and caches them on disk to avoid recompilation on subsequent requests."}

{"answer": "yes", "explanation": "In the dev environment, Symfony caches the compiled container and only rebuilds it 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)."}

{"answer": "yes", "explanation": "Symfony's controller resolver uses ReflectionMethod to invoke the action, which can call private, protected, or public methods regardless of visibility."}

{"answer": "no", "explanation": "Both subscribers and listeners are ordered by their numeric priority value; a listener with a higher priority will be called before a subscriber with a lower priority."}

{"answer":"yes","explanation":"Symfony 6.0 removed the old Guard system entirely, and the new authentication system is built around AuthenticatorInterface and its implementations."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute (Symfony 6.3+) checks a role or permission on a controller method and returns a 403 Forbidden response if the user lacks it."}

{"answer": "yes", "explanation": "Symfony Voters implement object-level access control, and isGranted('EDIT', $post) is the standard way to check permissions on a specific object using them."}

```json ⏎ {"answer": "yes", "explanation": "In Symfony 7+, the doctrine/annotations package is no longer a framework dependency, so PHP 8 attributes (#[Assert\NotBlank]) are the required and supported way to declare validation constraints."} ⏎ ```

{"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default (since Symfony 2.0), automatically adding and validating a CSRF token on submission."}

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

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

{"answer": "no", "explanation": "Symfony stores a serialized token (containing user identifier and roles) in the session, not the plain text password; passwords are hashed and stored in the database."}

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

{"answer": "yes", "explanation": "This is a well-known pattern (used by Symfony) where .env holds committed dev defaults and .env.local holds uncommitted real secrets."}

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

{"answer": "yes", "explanation": "Container::setParameter() is a public method that works at runtime, though it's generally discouraged in compiled (production) containers since already-resolved services won't see the updated value."}

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

{"answer": "no", "explanation": "Many Symfony bundles have sensible defaults and work without any configuration file in config/packages; only bundles that require specific settings need one."}

{"answer": "yes", "explanation": "In Symfony, environment variables are indeed injected into services.yaml using the %env(VAR)% syntax."}

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

{"answer": "no", "explanation": "Symfony Messenger supports multiple handlers per message; they are executed in order unless propagation is stopped explicitly."}

{"answer": "no", "explanation": "The sync transport processes the message immediately in the same process without queuing it for a worker; that's what async transports do."}

{"answer": "messenger:consume", "explanation": "The Symfony console command `messenger:consume` starts the worker that processes messages from Messenger queues."}

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

{"answer": "no", "explanation": "By default, Symfony Messenger uses PhpSerializer which relies on PHP's native serialize()/unserialize(), not JSON."}

{"answer": "yes", "explanation": "Symfony Scheduler is designed to trigger scheduled messages that are dispatched through the Messenger component."}

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

```json ⏎ {"answer": "yes", "explanation": "The Messenger pipeline supports custom middleware via the $middleware property on commands, which are processed in the pipeline before built-in middleware like ShouldBeUnique, and the pipeline pattern allows flexible ordering."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Symfony follows a release cycle with minor versions every 6 months (May and November) and major versions approximately every 2 years."} ⏎ ```

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

```json ⏎ {"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations; only PHP 8 native attributes are supported."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Symfony's AssetMapper component manages CSS/JS assets without Node.js or Webpack, using an importmap.php configuration file to define asset imports and dependencies."} ⏎ ```

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release, as all even-numbered minor versions in Symfony are LTS."}

```json ⏎ {"answer": "no", "explanation": "In Symfony's versioning policy, features deprecated in a major version are removed in the next major version."} ⏎ ```

{"answer": "yes", "explanation": "Symfony provides UPGRADE-*.md files in its repository for each major release, documenting breaking changes and deprecations."}

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

{"answer": "no", "explanation": "Following Symfony's 6-month release cycle, 7.4 (LTS) is expected in May 2026 and 8.0 in November 2026, meaning 8.2 would not be released until approximately November 2027."}

```json ⏎ {"answer": "yes", "explanation": "Symfony follows a six-month release cycle: 8.0 in November 2025, 8.1 in May 2026, and 8.2 in November 2026."} ⏎ ```

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

```json ⏎ {"answer": "no", "explanation": "Symfony 8.2 is a minor release (x.2), which is backward compatible and does not require rewriting; only major releases (x.0) introduce breaking changes."} ⏎ ```

{"answer": "yes", "explanation": "PHP follows semantic versioning: minor version updates within the same major branch (e.g., 8.1 → 8.2) are designed to preserve backward compatibility, so code should not require changes."}

{"answer": "8.4", "explanation": "Symfony follows a pattern where each major version has minor releases .0 through .4, with .4 being the LTS, making 8.4 the last minor release before 9.0."}

{"answer": "no", "explanation": "Symfony's minimum PHP requirement is set at the major version level (e.g., Symfony 8.0 would require PHP 8.4); minor releases like 8.2 typically maintain the same minimum PHP version rather than bumping it to a newer one like 8.5."}

{"answer": "yes", "explanation": "Symfony's policy guarantees that deprecations introduced in a given major version (8.x) are only removed in the next major version (9.0), ensuring backward compatibility within the major release."}

{"answer": "no", "explanation": "Twig's {{ }} tag uses its own limited expression language (variables, filters, method calls on objects, arithmetic), not arbitrary PHP code."}

{"answer": "yes", "explanation": "Twig has auto-escaping enabled by default, using the 'html' escaping strategy, which helps prevent XSS attacks."}

{"answer": "yes", "explanation": "The Twig |e (escape) filter defaults to the 'html' strategy, escaping strings for safe output in an HTML context."}

{"answer": "number_format", "explanation": "The number_format filter in twig/intl-extra formats a number according to a specified locale."}

{"answer": "yes", "explanation": "The |raw filter marks a value as safe, preventing the template engine from applying auto-escaping to it."}

{"answer": "yes", "explanation": "In Twig, {{ }} is the expression tag for outputting values, while {% %} is the statement tag for control structures like if, for, and set."}

{"answer": "no", "explanation": "In Twig you can declare variables inside a template using the {% set %} tag, so values are not only coming from the controller."}

{"answer": "dump", "explanation": "The dump() function in Twig outputs a debug representation of a variable, showing its structure for arrays, objects, etc."}

{"answer": "yes", "explanation": "Bootstrap is a CSS/JS library providing ready-made UI components (buttons, modals, grid, etc.), while SPA frameworks are things like React, Angular, or Vue.js."}

{"answer": "container", "explanation": "The .container class in Bootstrap provides a responsive fixed-width container with max-widths that change at each breakpoint."}

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

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

```json ⏎ {"answer": "no", "explanation": "The number in the class name is an index into a predefined spacing scale, not a direct multiple of $spacer (e.g., in Bootstrap 4, .mt-3 equals $spacer * 3/4, not $spacer * 3)."} ⏎ ```

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

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

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

```json ⏎ {"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; you must explicitly run schema update or migration commands to create/update the database schema."} ⏎ ```

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

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

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is designed to operate at the entity level, referencing entities and their mapped properties rather than raw database tables and columns."}

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

{"answer": "no", "explanation": "By default, DoctrineBundle does not automatically call flush() at the end of a request; you must either call flush() explicitly or enable the 'auto_commit' option in the configuration."}

{"answer": "yes", "explanation": "The Unit of Work performs dirty-checking on managed entities, so flush() automatically detects and commits property changes without needing an explicit persist() call."}

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

{"answer": "no", "explanation": "MVCC is designed so that readers do NOT block writers and writers do NOT block readers; that's the entire purpose of multi-version concurrency control."}

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

{"answer": "no", "explanation": "SERIAL is PostgreSQL-specific syntactic sugar that creates a separate sequence object, while GENERATED AS IDENTITY is a SQL-standard mechanism where the column itself is an identity column with different semantics (e.g., ALTER COLUMN vs ALTER SEQUENCE, GENERATED BY DEFAULT vs ALWAYS)."}

{"answer": "no", "explanation": "By default, PostgreSQL treats NULLs as distinct from each other, so a UNIQUE constraint allows multiple rows with NULL values in the column."}

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

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

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

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

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

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

{"answer": "yes", "explanation": "Indexes are used by the query optimizer to locate rows efficiently for SELECT, UPDATE, and DELETE operations that filter on indexed columns."}

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

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query to gather real performance data, while plain EXPLAIN shows the plan without execution."}

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

{"answer": "yes", "explanation": "A partial index in PostgreSQL includes only rows that satisfy the WHERE condition, reducing index size and improving query performance for matching queries."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI) with predicate locking and MVCC, not by locking the rows a transaction reads."}

{"answer": "yes", "explanation": "HTTP 201 'Created' indicates that the request was successful and a new resource has been 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": "no", "explanation": "Per RFC 9110 (Section 9.2.1), the idempotent methods are GET, HEAD, OPTIONS, PUT, and TRACE; DELETE is explicitly not included, because a second DELETE on an already-deleted resource returns 404, a different response than the first."}

{"answer": "no", "explanation": "Access-Control-Allow-Origin is sent by the server (as a response header), not by the client."}

{"answer": "yes", "explanation": "HTTP 429 'Too Many Requests' is specifically defined for rate limiting scenarios when a client exceeds the allowed request rate."}

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

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

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

{"answer": "no", "explanation": "Using == is vulnerable to type juggling (e.g., '0e...' strings) and timing attacks; hash_equals() should be used instead."}

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

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to define allowed sources of content and help mitigate XSS attacks."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol; the access token grants access to resources, while identifying the user (authentication) is handled by OpenID Connect's ID token."}

{"answer": "no", "explanation": "XSS is prevented by encoding/escaping output at the point of rendering, not by input validation before writing to the database."}

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

{"answer": "yes", "explanation": "Refresh tokens are designed to have a longer lifetime than access tokens and allow clients to obtain new access tokens without requiring the user to authenticate again."}

{"answer": "no", "explanation": "The salt does not need to be kept secret; it is typically stored alongside the hash so that verification can be performed."}

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

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

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

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

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

{"answer": "yes", "explanation": "In PHPUnit 10+, PHP 8 attributes like #[DataProvider] are the recommended replacement for the @dataProvider doc-comment annotation."}

{"answer": "no", "explanation": "PHPUnit allows test dependencies via the depends() method, which can skip a test if the test it depends on fails."}

{"answer": "--random-order", "explanation": "The --random-order PHPUnit flag shuffles the test execution order randomly."}

```json ⏎ {"answer": "3-3", "explanation": "intdiv(7,2) returns 3 and intdiv(-7,2) returns -3, concatenated as the string '3-3'."} ⏎ ```

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

{"answer": "true", "explanation": "'1e1' is a numeric string (scientific notation for 10), so both strings are compared as numbers, and 10 == 10 is true."}

{"answer": "zero", "explanation": "In PHP 8.0+, comparing a non-numeric string with an integer using == casts the string to an int, so 'a' becomes 0, which matches case 0."}

```json ⏎ {"answer": "2c", "explanation": "strtr with an array replaces longer keys first, so 'ab' is replaced with '2' before 'a' with '1', turning 'abc' into '2c'."} ⏎ ```

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

{"answer": "k,n,m", "explanation": "The array union operator + keeps keys from $a (k, n) and adds keys from $b that don't exist in $a (m), so array_keys returns ['k','n','m']."}

{"answer": "yxz", "explanation": "usort sorts by the third element (index 2), yielding order [1],[2],[2] → ['y','x','z'], which implode produces 'yxz'."}

```json ⏎ {"answer": 4, "explanation": "The spread operator with a string-keyed array maps values by key name to parameter names, so $a=5 and $b=1, giving 5-1=4."} ⏎ ```

{"answer": 3, "explanation": "The first-class callable syntax $p->g(...) creates a closure bound to the object at the time of creation, so even after $p = null, the closure still holds a reference to the original object and returns its private property $v = 3."}

{"answer": "B", "explanation": "static::class uses late static binding, so it returns the called class name (B) rather than the defining class (A)."}

{"answer": 10, "explanation": "The custom setter multiplies the assigned value by 2, so assigning 5 results in the property storing 10."}

{"answer": "BA", "explanation": "TB::f insteadof TA means f() resolves to TB's version returning 'B', and TA::f as g aliases TA's f() as g() returning 'A', so the concatenation is 'BA'."}

```json ⏎ {"answer": 0, "explanation": "Each class that uses a trait gets its own independent copy of the trait's static properties, so CX::$n and CY::$n are separate and CY::$n remains 0."} ⏎ ```

```json ⏎ {"answer": 2, "explanation": "A return statement in a finally block overrides the return value from the try block, so the function returns 2."} ⏎ ```

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

{"answer": "App\\Foo|Baz", "explanation": "Baz::class resolves to App\\Foo via the use alias, while \\Baz::class refers to the global class Baz."}

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

{"answer":"1,2,99","explanation":"After a foreach by reference, $v remains a reference to the last element of the array, so assigning 99 to $v changes the last element from 3 to 99."}

{"answer": 3, "explanation": "Static variables in PHP methods are shared between parent and child classes, so all calls to inc() increment the same variable: 0→1, 1→2, 2→3."}

```json ⏎ {"answer": "", "explanation": "After send(10), the generator is suspended at 'yield 1' (not complete), so getReturn() returns null, and echoing null produces an empty string."} ⏎ ```

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

```json ⏎ {"answer": "noyes", "explanation": "The hash was created with cost 4, so it doesn't need rehashing at cost 4 (no) but does need rehashing at cost 5 (yes)."} ⏎ ```

```json ⏎ {"answer": "strict-out", "explanation": "In PHP 8.4+, E_STRICT (2048) was removed from E_ALL, so the bitwise AND yields 0, making the condition true."} ⏎ ```

{"answer":"mapped","explanation":"Symfony's Request maps the HTTP_X_TOKEN server variable to the X-Token header, so get('X-Token') returns 'abc'."}

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

{"answer": "same", "explanation": "Doctrine's Identity Map (first-level cache) ensures that find() returns the already-managed entity instance for a given ID, so both $a and $b are the same object (in fact, the same as $u)."}

```json ⏎ {"answer": 0, "explanation": "Persisting then removing an entity before flush moves it from the insertions set to the deletions set in the UnitOfWork, so during flush only a DELETE is issued (affecting 0 rows since the INSERT never happened)."} ⏎ ```

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

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

{"answer": "M1M2", "explanation": "Middleware executes in order: Trace('M1') echoes 'M1' then delegates to the next, Trace('M2') echoes 'M2' then delegates to the final handler."}

```json ⏎ {"answer": 11, "explanation": "The HandleMessageMiddleware calls all registered handlers for the Ping class, so $n is incremented by 1 and then by 10, resulting in 11."} ⏎ ```

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

{"answer": 2, "explanation": "DEFERRABLE INITIALLY DEFERRED means the unique constraint is only checked at transaction end, so both inserts succeed and count(*) returns 2."}

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

{"answer": "2, 1", "explanation": "The data provider supplies two values (1 and -1), both tests run, but assertTrue(-1 > 0) fails for the second case."}

{"answer": "POST", "explanation": "curl's -d (or --data) flag sends data in the body and implicitly sets the HTTP method to POST."}

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

```json ⏎ {"answer": "invalid_client", "explanation": "RFC 6749 Section 5.2 defines 'invalid_client' as the error returned when client authentication fails, such as when the client_id is unknown to the authorization server."} ⏎ ```

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

{"answer": 0, "explanation": "The default filter only replaces null/undefined values (not false), so false remains false, which is cast to 0 in arithmetic, giving 0 * 3 = 0."}

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

{"answer": 0, "explanation": "NotBlank on an array checks if it is empty (count === 0); since [''] has one element, the constraint passes with 0 violations."}

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

{"answer": "same", "explanation": "Services in Symfony's DI container are shared (singleton) by default, so calling get() twice returns the same instance."}

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

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

```json ⏎ {"answer": "text-primary", "explanation": "In Bootstrap 5.3's compiled CSS, .text-primary appears after .text-danger, so it wins the cascade when both classes are present on the same element."} ⏎ ```

{"answer": 2, "explanation": "The Domain layer is in App\\Domain and depends on both App\\Application (PlaceOrder) and App\\Infrastructure (Db), but Domain may only depend on Domain — two violations."}

```json ⏎ {"answer": 3, "explanation": "The class is in the Domain layer which may only depend on Domain, but it references Application (PlaceOrder) and Infrastructure (Db, Logger), giving 3 violations."} ⏎ ```

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

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

{"answer": "hi", "explanation": "The code creates an instance of class C and calls its hi() method, which returns the string 'hi'."}

{"answer": "yesno", "explanation": "Before any property access the ghost is uninitialized (echoes 'yes'); after accessing $o->v the initializer runs and the object becomes initialized (echoes 'no')."}

```json ⏎ {"answer": "no", "explanation": "The Symfony Guard component was removed in Symfony 7.0, so AbstractGuardAuthenticator no longer exists in Symfony 8.1."} ⏎ ```

{"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 7.0, while AttributeClassLoader exists as its replacement."}