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

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

{"answer": "yes", "explanation": "The ?? (null coalescing) operator is equivalent to isset($var) ? $var : default, so it safely handles undefined variables without raising warnings."}

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

{"answer": "yes", "explanation": "In PHP, print is a language construct that outputs a string and always returns the integer 1, so it can be used within expressions."}

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

{"answer": "no", "explanation": "In PHP, the concatenation operator (.) has the same precedence as addition and subtraction; they are all at the same level in the precedence table."}

{"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": "sum: 5", "explanation": "The + operator has higher precedence than the . (concatenation) operator, so it's evaluated as 'sum: ' . (2 + 3) = 'sum: 5'."}

{"answer": "no", "explanation": "With ===, arrays must have the same key/value pairs in the same order to be considered equal."}

{"answer":"no","explanation":"0 == false uses a loose (non-strict) comparison and actually returns true, since false is cast to 0."}

{"answer": "no", "explanation": "In PHP 8, comparing a non-numeric string to an integer casts the integer to a string, 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 parses the leading numeric portion of a string and ignores the trailing non-numeric characters, so '42abc' becomes 42."}

{"answer": 10, "explanation": "PHP coerces the string '5' to the integer 5, then performs numeric addition: 5 + 5 = 10."}

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

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

{"answer":"no","explanation":"strrev() operates at the byte level, so it reverses individual bytes rather than multi-byte UTF-8 characters, producing a garbled result."}

{"answer": "yes", "explanation": "str_contains('Hello world', 'world') does return true because 'world' is a substring of 'Hello world'."}

{"answer": "no", "explanation": "str_pad() supports STR_PAD_RIGHT, STR_PAD_LEFT, and STR_PAD_BOTH as the pad_type parameter."}

{"answer": "no", "explanation": "By default, trim() strips spaces, tabs, newlines, carriage returns, null bytes, and vertical tabs — not just spaces."}

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

{"answer": "def", "explanation": "substr with a negative offset counts from the end of the string, so -3 returns the last 3 characters 'def'."}

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

{"answer": "yes", "explanation": "Heredoc supports variable interpolation like double-quoted strings, while nowdoc (identifier in single quotes) treats content as a plain string with no interpolation."}

{"answer": "no", "explanation": "The sort() function re-indexes the array numerically and does not preserve key-to-value associations; use asort() for that."}

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

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

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

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

{"answer": "[20, 30]", "explanation": "array_slice extracts 2 elements starting at offset 1, giving the sub-array [20, 30]."}

{"answer": 2, "explanation": "The array union (+) keeps the left value for duplicate keys ('a' => 1) and appends new keys from the right ('b' => 2), resulting in 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 extended the array spread operator to support arrays with string keys, which previously (since 7.4) only worked with integer-keyed arrays."}

{"answer": "no", "explanation": "In PHP 8.0+, named arguments can be combined with argument unpacking in a single call, as long as the named arguments appear before the ...$args unpacking (e.g., func(name: value, ...$args))."}

{"answer": "no", "explanation": "In PHP, anonymous functions (closures) do 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, which is 3 in this case, regardless of the declared parameter count."}

{"answer": "no", "explanation": "An arrow function (fn) in PHP has exactly a single expression as its body (e.g., fn($x) => $x * 2), not multiple expressions in curly braces."}

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

{"answer": "yes", "explanation": "A static closure in PHP explicitly opts out of binding $this, so it does not capture the current object context."}

{"answer": 5, "explanation": "The closure uses 'use ($x)' which captures the value of $x by value at the time of closure creation, so it remains 5 even after $x is reassigned to 7."}

{"answer": "yes", "explanation": "In weak typing mode (coercive mode), PHP will automatically coerce the numeric string '5' to the integer 5 when passed to a parameter with an int type hint."}

{"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": "The 'final' keyword in PHP prevents a method from being overridden in subclasses."}

{"answer": "yes", "explanation": "In PHP, a final method cannot be overridden by a subclass; attempting to do so will result in a fatal error."}

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

{"answer": "class@anonymous", "explanation": "In PHP, get_class() on an anonymous class returns 'class@anonymous' followed by a NUL byte and then the file path/line number."}

{"answer": "yes", "explanation": "In PHP, private methods are not visible to child classes, so they don't form part of the inheritance contract and the child is free to declare a same-named method with any visibility."}

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

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

{"answer": "yes", "explanation": "PHP interfaces are allowed to declare constants, which are always 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 implements a specific interface."}

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces can declare static methods."}

{"answer": "no", "explanation": "The instanceof operator in PHP checks both class inheritance and interface implementation."}

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

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

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

{"answer": "yes", "explanation": "In PHP, traits can 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 Exception and Error separately implement Throwable, so they are in different hierarchies."}

{"answer": "no", "explanation": "The @ operator only suppresses errors/warnings/notices, not exceptions; exceptions still propagate normally."}

{"answer": "ArithmeticError", "explanation": "intdiv() throws an ArithmeticError when the divisor is zero."}

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

{"answer": "no", "explanation": "An exception thrown in a finally block overrides the exception from the try/catch block, becoming the exception that propagates outward."}

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

{"answer": "yes", "explanation": "Shutdown functions registered via register_shutdown_function() are executed during the script shutdown phase, which is triggered by exit, die, normal script completion, or a fatal error."}

{"answer": "no", "explanation": "The use statement is merely an alias declaration at compile time; the class file is actually loaded only when the class is first used (e.g., instantiated), triggering the autoloader."}

{"answer": "function", "explanation": "In PHP, to import a function from a namespace you use 'use function Namespace\\functionName;'."}

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

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

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

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

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

{"answer": "yes", "explanation": "In PHP, a use statement for namespaces can be declared inside a function body, and the alias then applies only within that function's scope."}

{"answer": "yes", "explanation": "In PHP, arrays are copied by value on assignment (using copy-on-write internally for efficiency), not passed by reference."}

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

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

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

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

{"answer": "no", "explanation": "A foreach by value iterates over an internal copy of the array, so modifications to the original array inside the loop body do not affect the current iteration."}

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

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

{"answer": "yes", "explanation": "In PHP, a generator's `return` value (not yielded) is stored internally and can be retrieved after exhaustion via $gen->getReturn()."}

{"answer": "yes", "explanation": "PHP's Generator objects implement the Iterator interface, and calling rewind() resets a fully consumed generator back to its initial state so it can be iterated again."}

{"answer": "no", "explanation": "PHP has a `yield` keyword for generators but no `yield from` construct; that is a Python feature."}

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

```json ⏎ {"answer": 3, "explanation": "The generator yields 3 values (1, 2, 3), iterator_to_array produces an array with 3 elements, and count returns 3."} ⏎ ```

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

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

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

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

{"answer":"no","explanation":"In PHP 8, PASSWORD_DEFAULT is bcrypt (PASSWORD_BCRYPT), not md5."}

{"answer": "yes", "explanation": "password_verify() returns true because the plaintext 'secret' matches the hash generated from 'secret'."}

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

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

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

{"answer": "yes", "explanation": "session_destroy() only removes session data on the server side; the PHPSESSID cookie in the browser remains until it expires or is explicitly deleted with setcookie()."}

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

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

{"answer": "yes", "explanation": "Property hooks (get, set, update) were a major new feature introduced in PHP 8.4."}

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

{"answer": "8.4", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.4 to help developers remember to use the return values of functions."}

```json ⏎ {"answer": "8.4", "explanation": "The pipe operator |> was introduced in PHP 8.4, allowing function calls to be chained in a readable pipeline style."} ⏎ ```

{"answer": "no", "explanation": "The syntax clone($obj, ['x' => 1]) is not a feature implemented in any released PHP version; clone in PHP has always been the unary operator clone $obj."}

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

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

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

{"answer": "yes", "explanation": "The Context Manager v2 RFC was accepted for PHP 8.5 (released late 2025), so it is already adopted by November 2026."}

{"answer": "no", "explanation": "The RFC for Bound-Erased Generic Types was declined in 2024 (during the PHP 8.4 voting cycle), not in 2026."}

{"answer": "no", "explanation": "While PHP has offered a ZTS (Zend Thread Safe) build for years, the RFC to make ZTS the default build has not been accepted; PHP still defaults to NTS (Non-Thread Safe) builds."}

{"answer": "yes", "explanation": "As of PHP 8.5, native generics (parameterized types) have not been implemented; PHP still relies on documentation and static analysis tools to express generic type intentions."}

{"answer": "yes", "explanation": "PHP follows a roughly annual November release cycle, so PHP 8.5 would have been released in November 2025 and PHP 8.6's GA would come in November 2026, making 8.5 the latest stable as of 2026-11-07."}

{"answer": "yes", "explanation": "PHP 6 was planned but never released; PHP 7.0 followed PHP 5.6 directly."}

{"answer": "no", "explanation": "The RFC for the #[\\Deprecated] attribute was rejected during the voting phase and was not adopted into PHP core."}

{"answer": "yes", "explanation": "The dependency rule in clean/onion architecture mandates that dependencies point inward toward the domain, so inner layers have no knowledge of outer layers."}

{"answer": "yes", "explanation": "In clean architecture/DDD, domain entities should be pure PHP classes with no dependency on frameworks like Doctrine or Symfony, relying only on the language and possibly the standard library."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (web) layer, not the business-logic layer; they simply delegate to use cases which live in the application/domain layer."}

{"answer": "Entity", "explanation": "In onion architecture, the innermost layer contains the core domain entities, which hold the most critical business rules and logic."}

{"answer": "yes", "explanation": "Tools like deptrac enforce layer dependency rules and report/fail on forbidden cross-layer calls automatically."}

{"answer": "no", "explanation": "In clean architecture, a use case should depend on abstractions (e.g., a command object, a repository interface), not on concrete infrastructure like an HTTP request or an EntityManager."}

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

{"answer": "yes", "explanation": "In Clean Architecture, the database is a detail of the outermost layer (frameworks & drivers); use cases depend only on an interface (e.g., a repository port), so swapping the database only affects the adapter implementation."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of domain objects treated as a unit with a root entity that enforces invariants; it is a conceptual boundary, not a one-to-one mapping to a database table."}

{"answer": "yes", "explanation": "In DDD, a Value Object is defined as being immutable and determined by its attribute values rather than by a unique 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 pass."}

{"answer": "yes", "explanation": "In DDD, a repository is defined per Aggregate (root), encapsulating access to all entities within that aggregate, rather than creating a separate repository for each individual entity."}

{"answer": "yes", "explanation": "Ubiquitous Language, as defined in Domain-Driven Design, is a shared language between developers and domain experts to ensure the model's terms align with domain terminology."}

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

{"answer": "no", "explanation": "DDD recommends a rich domain model where objects encapsulate both state and behavior; the anemic model (logic in services) is considered an anti-pattern in DDD."}

{"answer": "yes", "explanation": "In DDD, a Bounded Context ensures that each context has its own domain model, so the same real-world concept (e.g., 'Product') can be modeled as different classes with different attributes and behaviors in different contexts."}

{"answer": "yes", "explanation": "Symfony's DI container instantiates services lazily, only when they are first requested, rather than eagerly 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 dependencies are resolved automatically by type-hinting, so you don't need to manually declare every service in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes and caches them (typically in the filesystem) to avoid recompilation on subsequent requests."}

{"answer": "yes", "explanation": "In the Symfony dev environment, the DI container is cached and only rebuilt when tracked files (e.g., service configs, class definitions) are detected as changed."}

{"answer": "APP_ENV", "explanation": "Since Symfony 5.1, the APP_ENV environment variable is used to select the active environment (dev/prod/test)."}

{"answer": "no", "explanation": "Symfony controller methods must be public because the controller resolver invokes them from outside the class using reflection."}

{"answer": "no", "explanation": "Subscribers are just a convenience for registering multiple listeners at once; once registered, both subscribers and listeners are subject to the same priority system with no inherent priority advantage for subscribers."}

{"answer": "yes", "explanation": "In Symfony 6.0 the old Guard system (GuardAuthenticationHandler, GuardAuthenticatorHandler, etc.) was removed, and authentication is fully based on classes implementing AuthenticatorInterface."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute in Symfony checks a role or permission on a controller method and returns a 403 Forbidden response if the user doesn't have the required access."}

{"answer": "yes", "explanation": "Voters in Symfony are the mechanism for defining custom access rules, including object-level permissions like isGranted('EDIT', $post)."}

```json ⏎ {"answer": "no", "explanation": "While PHP attributes are the recommended approach in Symfony 7+, doctrine annotations are still supported (deprecated but functional) if the doctrine/annotations package is installed."} ⏎ ```

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

{"answer": "yes", "explanation": "Symfony always validates forms server-side upon submission; client-side HTML5 validation is only a UX layer and is never relied upon as the sole validation mechanism."}

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

```json ⏎ {"answer": "no", "explanation": "Symfony stores the user's identity (e.g., user ID or username) in the session, not the password; the password is only used for comparison during authentication and is never persisted in the session."} ⏎ ```

{"answer": "yes", "explanation": "In modern Symfony (4+/Flex), bundle configurations are stored in config/packages/ with one file per bundle or topic (e.g., doctrine.yaml, twig.yaml)."}

```json ⏎ {"answer": "yes", "explanation": "This is a common best practice pattern (used in Laravel, Symfony, etc.) where .env holds safe dev defaults committed to the repo, and .env.local holds real secrets that are git-ignored."} ⏎ ```

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

{"answer": "yes", "explanation": "Symfony's container is a runtime object, so setParameter() can be called at any time during the request lifecycle to modify parameters."}

{"answer": "no", "explanation": "Since Symfony 4.3, services are private by default and cannot be fetched directly from the container unless explicitly marked public: true."}

```json ⏎ {"answer": "no", "explanation": "Many bundles work perfectly fine without a configuration file in config/packages, as they rely on sensible defaults."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony, environment variables are referenced in YAML configuration files using the %env(VAR)% syntax, e.g. %env(DATABASE_URL)%."}

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable in Symfony controls whether debug mode is enabled, affecting the profiler and Twig debugging."}

{"answer": "no", "explanation": "Symfony Messenger allows multiple handlers to be registered for the same message, and all of them will be invoked when the message is dispatched."}

{"answer": "no", "explanation": "The sync transport processes the message immediately in the same process by calling the handler directly, without queueing it for a worker."}

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

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

{"answer": "yes", "explanation": "Symfony Messenger uses the Symfony Serializer with JSON as the default serialization format."}

```json ⏎ {"answer": "yes", "explanation": "Symfony Scheduler is designed to define tasks on a schedule, and the typical pattern is to dispatch those tasks as messages through the Messenger component."} ⏎ ```

{"answer": "doctrine", "explanation": "The doctrine transport in Symfony Messenger persists messages in database tables using Doctrine DBAL."}

{"answer": "yes", "explanation": "Symfony Messenger allows you to add custom middleware and position them before, after, or at the end of the built-in middleware pipeline using the 'before', 'after', or 'append' options in the transport configuration."}

```json ⏎ {"answer": "no", "explanation": "Symfony major releases come every year (in November), while LTS versions come every two years; minor releases do come every six months in May and November."} ⏎ ```

```json ⏎ {"answer": "8.4", "explanation": "Symfony 8 requires a minimum PHP version of 8.4, following the pattern of increasing the minimum PHP requirement with each major release."} ⏎ ```

{"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations in favor of PHP 8 attributes; annotations were deprecated in 6.0 and removed in 7.0."}

{"answer": "yes", "explanation": "Symfony's AssetMapper manages CSS and JS assets using importmap.php without requiring Node.js or webpack."}

{"answer": "no", "explanation": "Symfony 6.4 is a Long-Term Support (LTS) release, not a regular release without long-term support."}

```json ⏎ {"answer": "no", "explanation": "In Symfony's policy, features deprecated in a given version (e.g., 4.4) are typically removed in the next major version (e.g., 5.0), so major releases do remove deprecations from the previous branch."} ⏎ ```

{"answer": "yes", "explanation": "Symfony provides UPGRADE-*.md files (e.g., UPGRADE-5.0.md, UPGRADE-6.0.md) for each major release documenting the changes."}

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

```json ⏎ {"answer": "no", "explanation": "Following Symfony's release cycle, Symfony 8.0 would be released around November 2026, meaning 8.2 would not come until mid-2027 at the earliest."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Following the six-month cycle from Symfony 7.0 (May 2024), Symfony 8.0 is scheduled for November 2026, not 8.2; 8.2 would be around November 2027."} ⏎ ```

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

{"answer": "no", "explanation": "Symfony 8.2 is a minor release (the second digit), not a major one; minor releases are backward-compatible and do not require rewriting applications."}

{"answer": "yes", "explanation": "PHP's backward compatibility promise guarantees that no code changes are needed when moving between minor versions within the same major version (e.g., 8.1 → 8.2)."}

{"answer": 8.4, "explanation": "Following Symfony's pattern where each major branch (4.x, 5.x, 6.x, 7.x) has minor versions up to .4, the 8.x branch would end at 8.4 before 9.0."}

{"answer": "no", "explanation": "Symfony version numbers and PHP version numbers do not correspond; there is no established rule that Symfony 8.2 would specifically require PHP 8.5."}

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

{"answer": "no", "explanation": "Inside {{ }} you can only use Twig's own expression language (variables, filters, operators, method calls via dot notation), not arbitrary PHP code."}

{"answer": "yes", "explanation": "Twig auto-escapes output by default using the HTML escaping strategy to prevent XSS attacks."}

{"answer": "yes", "explanation": "The Twig |e filter (alias for |escape) escapes a string for safe HTML output by default using htmlspecialchars with ENT_QUOTES."}

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

{"answer": "yes", "explanation": "In Laravel Blade, the |raw filter (equivalent to using {!! !!}) outputs the value without applying htmlspecialchars, thus disabling auto-escaping."}

{"answer": "yes", "explanation": "In Twig, double curly braces {{ }} are used to output/echo expression values, while percent braces {% %} are used for control structures like loops, conditions, and setting variables."}

{"answer": "no", "explanation": "Twig allows you to declare variables within a template using the {% set %} tag."}

{"answer": "dump", "explanation": "Twig's dump() function outputs a debug structure of a variable, similar to PHP's var_dump()."}

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

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

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

{"answer": "yes", "explanation": "Bootstrap 5 defines exactly five named breakpoints with class-name infixes: sm, md, lg, xl, and xxl."}

{"answer": "no", "explanation": "The spacing utilities use a predefined scale (e.g., .mt-1 = 0.25rem, .mt-2 = 0.5rem, .mt-3 = 1rem) that is not simply $spacer multiplied by the number; the formula in Bootstrap 4 is $spacer * $num / 4, so the values are not direct multiples of $spacer."}

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

{"answer": "yes", "explanation": "Bootstrap 5 removed the jQuery dependency and all its interactive components (dropdowns, modals, tooltips, etc.) are built with plain vanilla JavaScript (ES6+)."}

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

{"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; you must explicitly run schema tools or migrations 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."}

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

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) operates at the entity level, referencing entity names and their fields rather than raw table and column names."}

{"answer": "null", "explanation": "In Doctrine ORM and most PHP repositories, the find() method returns null when no record with the given ID exists."}

{"answer": "no", "explanation": "DoctrineBundle does not automatically call flush() at the end of a request; you must explicitly call $entityManager->flush() yourself (the old auto_commit option was deprecated and removed)."}

{"answer": "yes", "explanation": "The Unit of Work performs change detection on all managed entities at flush() time, so property modifications on managed entities are committed without needing an explicit persist() call."}

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

{"answer": "no", "explanation": "MVCC's purpose is the opposite: readers do not block writers and writers do not block readers, as each transaction sees its own version of the data."}

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

{"answer":"no","explanation":"While both use sequences under the hood, SERIAL is a PostgreSQL-specific shorthand that creates a separate sequence object with ownership, whereas GENERATED AS IDENTITY is a SQL-standard column property with different management semantics (e.g., the sequence is tied to the column and dropped with it, supports GENERATED ALWAYS/BY DEFAULT, and is modified via ALTER COLUMN ... IDENTITY)."}

```json ⏎ {"answer": "no", "explanation": "In PostgreSQL, by default, a UNIQUE constraint treats NULLs as distinct from each other, allowing multiple rows with NULL in that column."} ⏎ ```

{"answer": "STRING_AGG", "explanation": "STRING_AGG is the PostgreSQL aggregate function that concatenates strings with a specified separator."}

{"answer": "no", "explanation": "Plain VACUUM makes space reusable within the table but does not shrink the file; VACUUM FULL returns 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."}

{"answer":"no","explanation":"READ COMMITTED only protects against dirty reads; non-repeatable reads are protected at the REPEATABLE READ level or higher."}

{"answer": "yes", "explanation": "PostgreSQL defaults to autocommit mode, where each SQL statement is automatically committed upon completion unless an explicit transaction block (BEGIN/COMMIT) is used."}

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

```json ⏎ {"answer": "yes", "explanation": "Indexes help locate rows quickly for any DML operation (SELECT, UPDATE, DELETE) whose WHERE clause references the indexed column."} ⏎ ```

{"answer": "yes", "explanation": "SAVEPOINT allows you to roll back to a specific point within a transaction without aborting the entire transaction."}

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

{"answer": "pgvector", "explanation": "pgvector is the PostgreSQL extension that adds a vector data type and efficient indexing for similarity search on embeddings."}

{"answer": "yes", "explanation": "A partial index (CREATE INDEX ... WHERE ...) in PostgreSQL is indeed built only over rows that satisfy the given condition."}

{"answer": "no", "explanation": "PostgreSQL's SERIALIZABLE level uses Serializability Checking (SSI), an optimistic approach that detects conflicts at commit time, rather than locking all read rows (which is how SQL Server implements it)."}

{"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 7231/9110, DELETE is not listed among the idempotent methods (which are GET, HEAD, OPTIONS, PUT, TRACE); it is intentionally left open whether repeated DELETEs have the same effect."}

{"answer": "no", "explanation": "The Access-Control-Allow-Origin header is sent by the server, not the client; the client sends the Origin header instead."}

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

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

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not idempotent by default, whereas PUT is idempotent per RFC 7231."}

{"answer": "no", "explanation": "Using == for hash comparison is vulnerable to timing attacks; hash_equals() should be used instead as it performs a constant-time comparison."}

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

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to declare which resources are allowed to load and execute on a web page."}

```json ⏎ {"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol (granting access to resources), not an authentication protocol; authentication is added by OpenID Connect via the ID token."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "XSS is primarily prevented by encoding/escaping output when rendering it in HTML (e.g., htmlspecialchars), not by validating input before storing it in the database."} ⏎ ```

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

{"answer": "yes", "explanation": "Refresh tokens are designed to outlive access tokens and enable users to obtain new access tokens without re-authenticating."}

{"answer": "no", "explanation": "A salt does not need to be secret; it is typically stored alongside the hash (e.g., in a database). Its purpose is to ensure identical passwords produce different hashes, defeating precomputed rainbow tables, not to add secrecy."}

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

{"answer": "no", "explanation": "setUp() runs before each test method; setUpBeforeClass() is the one that 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 just one."}

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

{"answer": "no", "explanation": "It's the opposite: a stub only returns pre-programmed data, while a mock also verifies that certain methods were called with expected arguments."}

{"answer": "yes", "explanation": "PHPUnit 10+ recommends using the #[DataProvider] PHP attribute over the deprecated @dataProvider docblock annotation."}

{"answer": "no", "explanation": "PHPUnit supports test dependencies via the @depends annotation (or #[Depends] attribute in PHPUnit 10+), allowing a test to receive and use the result of another test."}

{"answer": "--order-by=random", "explanation": "PHPUnit's --order-by=random flag shuffles the test execution order to help identify order-dependent tests."}

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

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

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

{"answer": "other", "explanation": "In PHP 8+, comparing the string 'a' with integer 0 casts the integer to a string ('a' == '0'), which is false, so the default case is reached."}

{"answer": "2c", "explanation": "strtr with an array replaces longest keys first: 'ab' (length 2) matches before 'a' (length 1), so 'ab'→'2' is applied to 'abc' yielding '2c'."}

{"answer": "[]", "explanation": "substr('hello', -10) with start -10 exceeds the string length of 5, so in PHP 7.1+ it returns an empty string, giving output '[]'."}

{"answer": "k,n,m", "explanation": "The union operator (+) keeps keys from the left array and adds non-duplicate keys from the right, resulting in keys k, n, m."}

```json ⏎ {"answer": "yxz", "explanation": "usort sorts by the third element ascending (1,2,2), then array_column extracts index 1 giving 'y','x','z', which implode concatenates to 'yxz'."} ⏎ ```

{"answer": 4, "explanation": "The splat operator with an associative array expands to named arguments, so $a=5 and $b=1, giving 5-1=4."}

{"answer": 3, "explanation": "The first-class callable $p->g(...) captures the object reference at creation time, so setting $p = null does not affect the closure; it still calls g() on the original object and returns 3."}

{"answer": "B", "explanation": "static::class uses late static binding, returning the name of the class that was actually instantiated (B), not the class where the method is defined (A)."}

{"answer": 10, "explanation": "The set hook assigns $value * 2 directly to storage (without re-triggering itself), so the property holds 10."}

```json ⏎ {"answer": "BA", "explanation": "TB::f insteadof TA makes f() return 'B', and TA::f as g aliases TA's f() as g() returning 'A', so the concatenation is 'BA'."} ⏎ ```

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

{"answer": 2, "explanation": "A return statement in a finally block overrides the return in 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 exception being propagated, so the LogicException('second') is caught by the outer catch."}

```json ⏎ {"answer": "App\\Foo|Baz", "explanation": "Baz::class resolves to the aliased class App\\Foo, while \\Baz::class resolves to the global Baz class name as a string."} ⏎ ```

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

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

```php ⏎ {"answer": 3, "explanation": "Static variables in methods are shared per-class; since B inherits inc() from A, all instances share the same static $n, which increments to 1, 2, 3 across the three calls."} ⏎ ```

```json ⏎ {"answer": "", "explanation": "After send(10), the generator is still suspended at the yield point and not finished, so getReturn() returns null, which echoes as an empty string."} ⏎ ```

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

{"answer": "noyes", "explanation": "password_needs_rehash returns false (no) when cost matches (4=4) and true (yes) when cost differs (4≠5)."}

```json ⏎ {"answer": "strict-out", "explanation": "Since PHP 8.0, E_ALL no longer includes the E_STRICT bit (2048), so E_ALL & 2048 equals 0, making the condition true."} ⏎ ```

```json ⏎ {"answer": "mapped", "explanation": "Symfony's Request extracts HTTP_X_TOKEN from server variables into the headers bag as X-Token, so get('X-Token') returns 'abc'."} ⏎ ```

```json ⏎ {"answer": "BCA", "explanation": "Listeners are called in descending priority order: priority 10 (B), priority 5 (C), priority 0 (A)."} ⏎ ```

{"answer": "same", "explanation": "Doctrine's find() checks the identity map first, so the second call returns the exact same object instance already in memory."}

```json ⏎ {"answer": 0, "explanation": "When an entity is persisted and then removed before flush, Doctrine removes it from the insert schedule (since it was never in the DB, no DELETE is issued either), so no row is created."} ⏎ ```

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

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

{"answer": "M1M2", "explanation": "Symfony Messenger middleware executes in order (M1 first, then M2), each echoing its tag before passing to the next in the stack."}

```json ⏎ {"answer": 1, "explanation": "HandleMessageMiddleware only invokes the first handler in the array for the given message class, so only d1 (which adds 1) is called."} ⏎ ```

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

```json ⏎ {"answer": 2, "explanation": "With DEFERRABLE INITIALLY DEFERRED, the unique constraint is only checked at COMMIT, so both INSERTs succeed within the transaction, giving a count of 2."} ⏎ ```

```json ⏎ {"answer": 6, "explanation": "The --filter test_sum matches both test_sum (3 data sets) and test_sum_abs (3 data sets) as it's a regex substring match, totaling 6 tests."} ⏎ ```

{"answer": "2, 1", "explanation": "The data provider supplies two datasets ([1] and [-1]); the test passes for x=1 but fails for x=-1 since -1 > 0 is false."}

{"answer": "POST", "explanation": "The -d flag in curl causes it to send data in the request body, which automatically sets the HTTP method to POST."}

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

{"answer": "unauthorized_client", "explanation": "Per RFC 6749 Section 5.2, when the client is not recognized or not authorized, the token endpoint returns the error value 'unauthorized_client'."}

{"answer": "fragment", "explanation": "In the implicit flow (response_type=token), the access token is returned in the fragment part of the redirect_uri (after #), not in the query string."}

{"answer": 0, "explanation": "The default filter only replaces null/undefined values, so false|default(2) returns false, and false * 3 evaluates to 0 in Twig/PHP."}

{"answer": "a3", "explanation": "In Twig, the + operator has higher precedence than ~, so 1+2 is evaluated first to give 3, then 'a' is concatenated with 3 to produce 'a3'."}

```json ⏎ {"answer": 0, "explanation": "The value [''] is an array (not null, not scalar, and (string)[''] casts to 'Array' which is not empty after trim), so NotBlank passes with no violations."} ⏎ ```

```json ⏎ {"answer": "valid", "explanation": "Calling isValid() on an unsubmitted form triggers submit(null), and a TextType form with no validation constraints is valid with null data."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "Symfony's DI container caches service instances by default (singleton pattern), so calling get('a') twice returns the same object."} ⏎ ```

```json ⏎ {"answer": "hi Bob!", "explanation": "Symfony's container resolves nested parameter references during compile, so %greeting% expands to 'hi %name%' which further expands to 'hi Bob', giving 'hi Bob!'."} ⏎ ```

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

```json ⏎ {"answer": "text-danger", "explanation": "In Bootstrap 5.3's generated CSS, .text-danger appears after .text-primary (following the $theme-colors map order: primary, secondary, success, danger, warning, info), so with equal specificity, .text-danger wins."} ⏎ ```

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

```json ⏎ {"answer": 3, "explanation": "Domain can only depend on Domain, but BillingService (Domain) depends on Application\\PlaceOrder, Infrastructure\\Db, and Infrastructure\\Logger — three violations."} ⏎ ```

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

{"answer": 1, "explanation": "The remove() method throws a DomainException when count is 1, before calling unset(), so the item 'a' is never removed and count() still returns 1."}

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

{"answer": "yesno", "explanation": "The lazy ghost is uninitialized before property access (prints 'yes'), then accessing $o->v triggers initialization and materializes the object (prints 'no')."}

{"answer": "no", "explanation": "The Guard authentication system was removed in Symfony 6.0, so AbstractGuardAuthenticator does not exist in 8.1."}

```json ⏎ {"answer": "noyes", "explanation": "AnnotationClassLoader was deprecated in 6.1 and removed in 7.0, while AttributeClassLoader (the replacement) exists in all modern Symfony versions."} ⏎ ```