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

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

{"answer": "yes", "explanation": "The null coalescing operator (??) is equivalent to isset($expr) ? $expr : default, so it does not raise warnings for undefined variables or array keys."}

{"answer": "ab", "explanation": "In PHP, echo accepts multiple comma-separated arguments and outputs them concatenated."}

{"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 in expression contexts like $x = print('hello')."}

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

{"answer": "yes", "explanation": "In PHP, arithmetic operators (+, -, *, /) have higher precedence than the concatenation operator (.), so '1 + 2 . 3' evaluates to '33'."}

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

{"answer": 3, "explanation": "Concatenation (.) has higher precedence than addition (+), so it's parsed as ('sum: ' . 2) + 3, which becomes 'sum: 2' + 3, and 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 to be considered equal."}

{"answer": "no", "explanation": "0 == false actually returns true because == is a loose comparison and false is cast to 0, making 0 == 0 true."}

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

{"answer": "no", "explanation": "In PHP 8+, null == '' is false, so null is not loosely equal to all three at the same time."}

{"answer": 42, "explanation": "PHP casts a string to int by reading the leading numeric portion, so '42abc' becomes 42."}

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

{"answer": "yes", "explanation": "In PHP, casting false to a string (string) false yields the string \"0\"."}

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

{"answer": "no", "explanation": "strrev() reverses individual bytes, not multi-byte UTF-8 characters, so it will corrupt multi-byte characters."}

{"answer": "yes", "explanation": "str_checks if the needle 'world' is found in the haystack 'Hello world', which it is, so it returns true."}

{"answer": "no", "explanation": "str_pad() can pad on the right, left, or both sides using the STR_PAD_RIGHT, STR_PAD_LEFT, and STR_PAD_BOTH constants."}

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

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

{"answer": "def", "explanation": "substr with a negative start of -3 begins 3 characters from the end of 'abcdef', returning the substring '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 strings support variable interpolation, while nowdoc strings (delimiters wrapped in single quotes) treat the content as a plain string with no interpolation."}

{"answer": "no", "explanation": "The sort() function reindexes the array with numeric keys, destroying key associations; use asort() to preserve them."}

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

{"answer": "no", "explanation": "in_array() uses loose comparison (==) by default; the third parameter $strict defaults to false."}

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

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

{"answer": "[20, 30]", "explanation": "array_slice starts at offset 1 and extracts 2 elements from the array, yielding [20, 30]."}

{"answer": 2, "explanation": "The + operator performs array union where left keys take precedence, so 'a' stays 1 and 'b' is added, giving 2 elements."}

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

{"answer": "no", "explanation": "In PHP 8.0+, named arguments can be freely combined with argument unpacking (both positional and named) in a single function call."}

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

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

{"answer": "no", "explanation": "An arrow function (fn) body is a single expression without curly braces; for multiple statements you need a regular closure."}

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

{"answer": "yes", "explanation": "A static closure in PHP explicitly does not bind to the current scope's $this, even when defined inside a class method."}

{"answer": 5, "explanation": "The `use ($x)` captures $x by value at closure creation time, so the closure retains 5 even after $x is reassigned to 7."}

{"answer": "yes", "explanation": "In weak typing mode, PHP will coerce numeric strings like \"5\" to integers when passed to int-typed parameters."}

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

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

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

{"answer": "no", "explanation": "Private properties are only accessible within the class that defines them, not in subclasses. Use protected for that purpose."}

```json ⏎ {"answer": "class", "explanation": "In PHP, an anonymous class created with `new class {}` gets a name where the part before the NUL byte (before `@anonymous`) is `class`."} ⏎ ```

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

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

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP throws an Error (not an Exception), with a message like 'Cannot modify readonly property'."}

{"answer": "yes", "explanation": "PHP interfaces can declare constants, which are always public and readonly by nature."}

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

{"answer": "yes", "explanation": "In PHP, an interface can declare static methods; the implementing class must then provide a static method with a matching signature."}

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

{"answer": "no", "explanation": "Interface methods in PHP must be abstract (declared without a body); they cannot have default implementations, unlike trait methods."}

{"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 of all enum cases, and this enum has 3 cases: A, B, and C."}

{"answer": "yes", "explanation": "Since PHP 8.2, traits are allowed to declare constants."}

{"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; they are siblings under the Throwable interface, so catch(Exception) does not catch TypeError."}

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

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

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

{"answer": "no", "explanation": "An exception thrown in a finally block overrides and replaces any exception being thrown from the try block, so it does have an effect."}

{"answer": "yes", "explanation": "In PHP, casting any object to bool always results in true."}

{"answer": "yes", "explanation": "Shutdown functions registered with register_shutdown_function() are executed during the shutdown phase, which occurs whether the script ends normally, via exit/die, or due to a fatal error."}

{"answer":"no","explanation":"The use statement is a compile-time alias only; it does not trigger the autoloader or load the class file. The file is loaded when the class is actually referenced at runtime."}

{"answer": "function", "explanation": "In PHP, the syntax 'use function' is used to import a function from a namespace, while 'use const' is used for constants."}

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

{"answer": "yes", "explanation": "Composer's vendor/autoload.php calls spl_autoload_register() to register the Composer\\Autoload\\ClassLoader with PHP's SPL autoloading mechanism."}

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

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

{"answer": "yes", "explanation": "PSR-4 maps the namespace App\\ to src/, so the remaining sub-namespace Model and class User produce the path src/Model/User.php."}

{"answer": "no", "explanation": "In PHP, use statements for namespace imports must be declared in the outermost (global) scope of a file and cannot be placed inside a function body."}

{"answer": "yes", "explanation": "In PHP, arrays follow value semantics by default — assigning an array to another variable creates a copy (using copy-on-write optimization), so modifications to one do not affect the other unless explicit reference (&) is used."}

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

{"answer": "yes", "explanation": "PHP variables have function scope, so global variables must be explicitly imported via global, $GLOBALS, or passed as parameters to be accessible inside a function."}

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

{"answer": 6, "explanation": "The function increments $x by reference, so $n is modified from 5 to 6."}

{"answer": "no", "explanation": "PHP's foreach by value iterates over a snapshot of the array; modifications to the array inside the loop body do not affect the current iteration pass."}

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

{"answer": "no", "explanation": "In PHP, boolean values used as array keys are cast to integers (true → 1, false → 0), so they are never stored as bool keys."}

{"answer": "yes", "explanation": "In PHP generators, a `return` with a value is stored internally and can be retrieved via `$gen->getReturn()` once the generator is exhausted."}

{"answer": "no", "explanation": "PHP generators are single-pass; once fully consumed, rewind() cannot reset them for re-traversal."}

{"answer": "yes", "explanation": "yield from is a Python construct that delegates iteration to another generator or iterable, yielding each item from it."}

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

{"answer": 3, "explanation": "The generator yields three values (1, 2, 3), iterator_to_array converts it to an array of 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 one 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() methods."}

{"answer": "no", "explanation": "ArrayObject implements IteratorAggregate, 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; it does not accept a salt parameter."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT in PHP 8 is argon2id (or argon2i), not MD5; MD5 is a fast hash unsuitable for password storage."}

{"answer": "true", "explanation": "password_verify() returns true when the provided password matches the given hash."}

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags and is relevant to XSS mitigation, not SQL injection prevention, which requires parameterized queries or proper escaping."}

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

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

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

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

{"answer": 8.3, "explanation": "The array_find() function was introduced in PHP 8.3 along with array_find_key(), first(), and last()."}

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

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

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

{"answer": "no", "explanation": "The pipe operator |> has never been part of PHP's language syntax in any version."}

{"answer": "no", "explanation": "No such 'clone-with' syntax exists in any PHP version; it is a fabricated feature."}

{"answer": "They don't exist", "explanation": "array_first() and array_last() are not standard PHP functions in any released version of PHP."}

{"answer": "no", "explanation": "There is no known PHP RFC titled 'Partial Function Application v2' that was adopted into any PHP version."}

{"answer": "8.5", "explanation": "The clamp_v2 RFC was accepted for PHP 8.5 after the original clamp() was removed from PHP 8.4."}

{"answer": "no", "explanation": "There is no 'Context Managers v2' RFC that has been adopted into PHP; this appears to be a fabricated or non-existent RFC."}

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

{"answer": "no", "explanation": "No such RFC has been accepted; PHP remains single-threaded by default, and even Fibers (PHP 8.1) are cooperative concurrency on a single thread, not true multithreading."}

{"answer": "yes", "explanation": "PHP has never implemented built-in generics (parameterized types); developers rely on conventions and documentation instead."}

{"answer": "yes", "explanation": "PHP releases typically land in late November, so PHP 8.5 (released ~Nov 2025) would be the latest stable as of 2026-11-07, with PHP 8.6 expected shortly after (GA 2026-11-19)."}

{"answer": "yes", "explanation": "PHP 6 was never released; the work intended for it was incorporated into PHP 7.0, which followed PHP 5.6 directly."}

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

{"answer": "yes", "explanation": "The Dependency Rule in Clean/Onion Architecture states that source code dependencies must point only inward, meaning inner layers have no knowledge of outer layers."}

{"answer": "yes", "explanation": "In Domain-Driven Design, domain entities belong to the domain layer which must be framework-agnostic, depending only on the language and possibly standard library."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (interface) layer, not the business-logic layer; they simply depend on and call use cases from that outer layer."}

{"answer": "Entity", "explanation": "The very center of the onion architecture contains the domain entities and core business rules, which have no dependencies on anything else."}

{"answer": "yes", "explanation": "Tools like deptrac analyze static dependencies between layers and can fail the build when a forbidden layer-to-layer call is detected."}

{"answer": "no", "explanation": "A use case (interactor) should be framework-agnostic; it should accept plain data/DTOs and depend on abstractions (e.g., repository interfaces) rather than concrete framework objects like HTTP requests or EntityManagers."}

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

{"answer": "yes", "explanation": "In clean architecture, the domain and use cases depend on abstract interfaces (e.g., a Repository), so swapping the concrete database implementation in the outer infrastructure layer leaves them untouched."}

{"answer": "no", "explanation": "An aggregate is a DDD domain concept representing a consistency boundary of related domain objects, not a database table; it can span multiple tables or share tables with other aggregates."}

{"answer": "yes", "explanation": "In DDD, a Value Object is defined by its immutability and value-based equality, meaning two instances with the same field values are considered equal regardless of identity."}

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

{"answer": "yes", "explanation": "In DDD, a repository is defined per aggregate root, and all entities within that aggregate are accessed through the root, not via their own repositories."}

{"answer": "yes", "explanation": "Ubiquitous Language, a concept from Domain-Driven Design (Eric Evans), is indeed the shared vocabulary used consistently by both developers and domain experts throughout the project."}

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

{"answer": "no", "explanation": "DDD recommends a rich domain model where business logic is encapsulated in entities and value objects, not an anemic model with logic pushed into services."}

{"answer": "yes", "explanation": "In DDD, a Bounded Context defines a boundary where a model is valid, and the same real-world concept can be modeled as different classes in different contexts."}

{"answer": "yes", "explanation": "Symfony's DI container is lazy by design: services are only instantiated the first time they are requested, not at container build time."}

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

{"answer": "no", "explanation": "Autowiring (combined with autoconfiguration) automatically resolves dependencies based on type hints, so most services don't need to be manually declared in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles template files into PHP classes that extend \\Twig\\Template and caches them (typically in a filesystem cache) to avoid recompilation on subsequent requests."}

{"answer": "yes", "explanation": "In the dev environment Symfony caches the compiled container and only rebuilds it when tracked dependency files have changed, not on every request."}

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

{"answer": "no", "explanation": "Symfony controller methods used as route handlers must be public; the routing system invokes them via reflection and requires them to be accessible."}

{"answer": "no", "explanation": "Subscribers and listeners are treated identically by the event dispatcher; both are ordered by their numeric priority value, not by their type."}

{"answer": "yes", "explanation": "The legacy guard authentication system was deprecated in Symfony 5.3 and fully removed in Symfony 6.0, leaving only the new authenticator-based security system."}

{"answer": "IsGranted", "explanation": "The IsGranted attribute in Symfony checks if the user has a specified role or permission on a controller method, throwing a 403 AccessDeniedException if they don't."}

{"answer": "yes", "explanation": "Voters in Symfony are the mechanism for object-level security checks, allowing you to use isGranted('EDIT', $post) to check access to a specific object."}

{"answer": "yes", "explanation": "Symfony 7 removed support for Doctrine annotations entirely; PHP attributes (e.g. #[Assert\\NotBlank]) are the only supported way to declare validation constraints."}

{"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default; each form automatically includes a CSRF token that is validated on submission."}

{"answer": "yes", "explanation": "Symfony always re-validates form data on the server regardless of any client-side HTML5 validation, as client-side checks can be bypassed."}

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

{"answer": "no", "explanation": "Symfony stores a serialized user token (user ID and roles) in the session, never the plain-text password; passwords are only kept in hashed form in the database."}

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

{"answer": "yes", "explanation": "This is the standard pattern (e.g., in Symfony) where .env holds committed dev defaults and .env.local holds uncommitted local secrets."}

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

{"answer": "no", "explanation": "The Symfony container is compiled/frozen at runtime; parameters are resolved at compile time and setParameter() is not available on the production (compiled) container."}

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

{"answer": "no", "explanation": "Many bundles in Symfony have sensible defaults and work perfectly fine without any configuration file in config/packages/."}

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

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

{"answer": "no", "explanation": "Symfony Messenger allows multiple handlers to be registered for the same message, and they will all be invoked in order (unless one stops the chain)."}

{"answer": "no", "explanation": "The sync transport does not queue the message; it immediately dispatches it to the handler within the same process, bypassing any worker."}

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

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

{"answer": "yes", "explanation": "Symfony Messenger's default Serializer uses the 'json' format when encoding messages for transport."}

{"answer": "no", "explanation": "Symfony Scheduler schedules and executes tasks (implementing the Task interface) at defined intervals, not specifically producing and dispatching messages through Messenger."}

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

{"answer": "yes", "explanation": "Laravel's Messenger allows you to define custom middleware in the getMiddleware() method, and you can position them before or after built-in middleware like Dispatchable, SerializesModels, and Queueable."}

{"answer": "yes", "explanation": "Symfony releases minor versions every six months (May and November) and major versions every two years (November)."}

{"answer": "8.2", "explanation": "Symfony 7 (the latest major release) requires PHP 8.2 as its minimum version; Symfony 8 is not yet released but is expected to require at least PHP 8.2."}

{"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations; PHP 8 attributes are now required."}

{"answer": "yes", "explanation": "Symfony's AssetMapper component handles CSS/JS asset management using an importmap (importmap.php) without requiring Node.js or webpack."}

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

{"answer": "no", "explanation": "Symfony's policy is that deprecated features introduced in one major version are removed in the next major release."}

```json ⏎ {"answer": "yes", "explanation": "Symfony provides UPGRADE guides (UPGRADE-X.Y.md files in components and upgrade pages in the documentation) for each major release to help developers migrate."} ⏎ ```

{"answer": "AssetMapper", "explanation": "Symfony's AssetMapper component manages assets and importmaps without requiring Node.js or webpack."}

```json ⏎ {"answer": "no", "explanation": "Based on Symfony's typical release cadence (~6 months per minor version), by November 2026 the latest would likely be around Symfony 8.0 or 8.1 at most, making 8.2 unlikely to have been released yet."} ⏎ ```

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

{"answer": "8.2", "explanation": "Symfony follows sequential minor version numbering, so the version after 8.1 is 8.2."}

{"answer": "no", "explanation": "Major Symfony releases introduce breaking changes requiring migration, not a complete rewrite of applications."}

{"answer": "yes", "explanation": "PHP guarantees backward compatibility within a major version branch, so upgrading from 8.1 to 8.2 should not break existing code."}

{"answer": "8.4", "explanation": "Following Symfony's pattern of releasing an LTS at the .4 minor version (4.4, 5.4, 6.4), the last minor version of the 8.x branch before 9.0 would be 8.4."}

{"answer": "no", "explanation": "Symfony's PHP requirements don't follow a 1-to-1 version mapping; Symfony 8.x would require PHP 8.3 or 8.4, not PHP 8.5."}

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

{"answer":"no","explanation":"Twig is a sandboxed template engine that only allows a restricted set of functions, filters, and operators inside {{ }}, not arbitrary PHP code."}

{"answer": "yes", "explanation": "Twig enables auto-escaping with the 'html' strategy by default to prevent XSS vulnerabilities."}

{"answer": "yes", "explanation": "The |e filter is an alias for |escape and by default uses the 'html' strategy to escape special characters for safe HTML output."}

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

{"answer": "yes", "explanation": "In Twig, the |raw filter marks a value as safe, preventing auto-escaping from being applied to it."}

{"answer": "yes", "explanation": "In Twig, {{ }} is used to output/print expression values, while {% %} is used to execute control structures and statements like conditions, loops, and set."}

{"answer": "no", "explanation": "Twig allows declaring variables inside templates using the `set` tag, e.g. {% set title = 'Hello' %}."}

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

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

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

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

{"answer": "yes", "explanation": "Bootstrap 5 defines exactly five named breakpoints with infixes: sm, md, lg, xl, and xxl (the base/xs breakpoint uses no infix)."}

{"answer": "yes", "explanation": "In Bootstrap, spacing utilities like .mt-3 or .px-2 calculate their value as the number multiplied by the $spacer variable (e.g., $spacer * 3)."}

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

{"answer": "yes", "explanation": "Bootstrap 5 removed its jQuery dependency entirely and all interactive components are built with plain 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 auto-create tables at runtime; schema creation must be explicitly triggered via commands like doctrine:schema:create or migrations."} ⏎ ```

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

{"answer": "no", "explanation": "EntityManager::merge() was removed in Doctrine ORM 3; it was deprecated in ORM 2 and no longer available in ORM 3."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is object-oriented and operates on entities and their fields, not on database tables and columns."}

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

{"answer": "no", "explanation": "DoctrineBundle does not automatically call flush() at the end of a request; you must explicitly call $entityManager->flush() to persist changes."}

{"answer": "yes", "explanation": "A managed entity is already tracked by the Unit of Work, so property changes are detected during flush() without needing an explicit persist() call."}

{"answer": "no", "explanation": "Doctrine's 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 specifically designed so that readers do NOT block writers and writers do NOT block readers; each transaction sees a consistent snapshot of the data."}

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

{"answer": "no", "explanation": "SERIAL creates a separate sequence object and sets it as the column's DEFAULT, while GENERATED AS IDENTITY is an SQL-standard feature built into the column definition itself; they differ in internals, DDL behavior, and metadata visibility."}

{"answer": "no", "explanation": "PostgreSQL treats NULL values as distinct from each other in UNIQUE constraints, so multiple rows can have NULL in that column by default."}

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

{"answer": "no", "explanation": "Plain VACUUM marks the space as reusable within the table but does not return it to the OS; only VACUUM FULL (which rewrites the table) 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 addressed by the REPEATABLE READ isolation level."}

{"answer": "yes", "explanation": "PostgreSQL operates in autocommit mode by default, where each SQL statement is automatically committed upon completion unless explicitly wrapped in a BEGIN/COMMIT block."}

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

{"answer": "yes", "explanation": "Indexes are used to locate rows in SELECT, UPDATE, and DELETE statements alike, so all three benefit from indexed columns in the WHERE clause."}

{"answer": "yes", "explanation": "SAVEPOINT in PostgreSQL allows rolling back to a specific point within a transaction, undoing only the statements executed after that savepoint."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query to collect real execution times and row counts, unlike plain EXPLAIN which only shows the plan without running it."}

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

{"answer": "yes", "explanation": "A partial index only includes entries for rows that satisfy the specified WHERE condition, making it smaller and more efficient for queries targeting that subset."}

{"answer":"no","explanation":"PostgreSQL's SERIALIZABLE level uses Serializable Snapshot Isolation (SSI), which detects and aborts conflicting transactions rather than locking the rows a transaction reads."}

{"answer": "yes", "explanation": "HTTP 201 'Created' indicates that the request has been successfully fulfilled 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": "The HTTP specification (RFC 7231) explicitly lists GET, HEAD, OPTIONS, and PUT as idempotent methods, but does NOT include DELETE in that set."}

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

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

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

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not idempotent, whereas PUT is required to be idempotent per the HTTP specification."}

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

{"answer": "yes", "explanation": "CSRF tokens are indeed generated server-side, tied to the user's session, and validated on the server when handling unsafe HTTP methods like POST, PUT, or DELETE."}

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

{"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol, not an authentication protocol; the access token grants access to specific resources (scopes) rather than identifying who the user is."}

{"answer": "no", "explanation": "XSS is prevented by context-aware output encoding/escaping at the point of rendering, not by input validation before storing data."}

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

{"answer": "yes", "explanation": "Refresh tokens are designed to have a longer expiration than access tokens and are used to request new access tokens without requiring the user to re-authenticate."}

{"answer": "no", "explanation": "A salt does not need to be kept secret; it is typically stored alongside the hash (e.g., in a database) and its security value comes from uniqueness and the hash algorithm's cost, not secrecy."}

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

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

{"answer": "no", "explanation": "A data provider is specifically designed to supply multiple sets of arguments, each causing a separate test run."}

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

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

{"answer": "yes", "explanation": "PHPUnit 10 deprecated docblock annotations like @dataProvider in favor of the native PHP attribute #[DataProvider]."}

{"answer": "no", "explanation": "PHPUnit allows test dependencies via the @depends annotation or the depends() method, which skips a test if the one it depends on fails."}

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

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

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

```json ⏎ {"answer": "false", "explanation": "In PHP 8+, two strings are compared as strings (lexicographically), so '1e1' != '10'."} ⏎ ```

{"answer": "zero", "explanation": "In PHP 7, switch uses loose comparison (==), and a non-numeric string like 'a' cast to int equals 0, so 'a' == 0 is true."}

{"answer": "2c", "explanation": "strtr with an array replaces the longest matching key first, so 'ab' matches before 'a', yielding '2' + 'c' = '2c'."}

```php ⏎ echo '[' . substr('hello', -10) . ']'; ⏎ ``` ⏎  ⏎ ```json ⏎ {"answer": "[]", "explanation": "substr('hello', -10) returns an empty string because abs(-10) > strlen('hello') (5), so the output is '[' + '' + ']'.\"} ⏎ ```

{"answer": "k,n,m", "explanation": "The + operator does a union keeping keys from the left array first; $a has keys 'k','n' and $b contributes 'm' (since 'k' is already in $a), so array_keys returns ['k','n','m']."}

{"answer": "yxz", "explanation": "usort sorts sub-arrays by their third element (values 2,1,2 → 1,2,2), so the order becomes [2,'y',1], [1,'x',2], [3,'z',2], then array_column extracts index 1 giving 'y','x','z', and implode concatenates to 'yxz'."}

{"answer": 4, "explanation": "The spread operator with a string-keyed array maps keys to named parameters, so a=5 and b=1, giving 5-1=4."}

{"answer": 3, "explanation": "The first-class callable $f captures the object instance, so even after $p is set to null, the closure still holds a reference to the object and can call g() which returns 3."}

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

```json ⏎ {"answer": "error", "explanation": "Assigning to $this->x inside its own set hook triggers the set hook again, causing infinite recursion and a fatal error."} ⏎ ```

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

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

```json ⏎ {"answer": 2, "explanation": "In PHP, a return statement in a finally block overrides the return from the try block, so f() returns 2."} ⏎ ```

```json ⏎ {"answer": "second", "explanation": "When a new exception is thrown in a finally block, it replaces the original 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 namespace class Baz."}

{"answer": "noyes", "explanation": "class_exists('Foo') checks the global namespace (no Foo there) → 'no'; class_exists('Ns\\Foo') finds the namespaced class → 'yes'."}

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

{"answer": 3, "explanation": "Static variables in inherited methods are shared between parent and child classes, so all three calls increment the same $n to 1, 2, 3."}

```json ⏎ {"answer": "", "explanation": "The first send() call starts the generator which suspends at 'yield 1' (the sent value is ignored on the first call), so the generator has not returned and getReturn() yields null, which echoes as an empty string."} ⏎ ```

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

```json ⏎ {"answer": "noyes", "explanation": "The hash was created with cost 4, so password_needs_rehash with cost 4 returns false ('no'), but with cost 5 it returns true ('yes') because the cost changed."} ⏎ ```

```json ⏎ {"answer": "strict-out", "explanation": "In PHP 8.5, E_STRICT (bit 2048) has been removed, so E_ALL no longer includes that bit, making the bitwise AND equal to 0."} ⏎ ```

{"answer": "mapped", "explanation": "Symfony's HeaderBag normalizes 'HTTP_X_TOKEN' from the server array to 'x-token', and get('X-Token') also normalizes to 'x-token', so the values match."}

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

{"answer": "same", "explanation": "EntityManager::find() checks the identity map first; since the entity is already managed after persist+flush, both calls return the same object instance."}

```json ⏎ {"answer": 0, "explanation": "Persisting a new entity and then removing it before flush cancels the pending INSERT (or results in an INSERT followed by a DELETE), leaving the table empty."} ⏎ ```

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

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

```json ⏎ {"answer": "M1M2", "explanation": "Symfony Messenger middleware executes in order (first to last), so M1 echoes first, then calls next which is M2, which echoes and delegates to the handler."} ⏎ ```

```json ⏎ {"answer": 11, "explanation": "Both handlers registered for Ping::class in the HandlersLocator are called, so $n is incremented by 1 and by 10, resulting in 11."} ⏎ ```

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

{"answer": 2, "explanation": "The UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, so the duplicate check is postponed until the end of the transaction, allowing both inserts to succeed and count(*) returns 2."}

{"answer": 6, "explanation": "The --filter test_sum regex matches both test_sum and test_sum_abs (each with 3 data provider entries), giving 3 + 3 = 6 tests."}

{"answer": "2, 1", "explanation": "The data provider yields two data sets ([1] and [-1]), so test_x runs twice; the first passes (1 > 0 is true) and the second fails (-1 > 0 is false)."}

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

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

```json ⏎ {"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, when the client identity cannot be verified (e.g., a non-existent client_id), the token endpoint returns the 'invalid_client' error code."} ⏎ ```

{"answer": "fragment", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access token is passed in the fragment identifier (the part after '#') of the redirect_uri."}

{"answer": 0, "explanation": "The `default` filter only replaces null or undefined values, not `false`, so `false|default(2)` yields `false`, and `false * 3` evaluates to `0` in PHP's arithmetic context."}

```json ⏎ {"answer": 2, "explanation": "In Twig, the ~ (concatenation) operator has higher precedence than +, so 'a' ~ 1 + 2 is parsed as ('a' ~ 1) + 2, which gives 'a1' + 2, and PHP casts the non-numeric string to 0, resulting in 2."} ⏎ ```

```json ⏎ {"answer": 0, "explanation": "The array [''] is not empty (it has one element), so Assert\\NotBlank passes without any violation."} ⏎ ```

```json ⏎ {"answer": "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": "Symfony DI services are shared (singleton) by default, so both calls to get('a') return the same object instance."}

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

{"answer": 960, "explanation": "At the 992px viewport, the lg breakpoint applies, giving .container a max-width of 960px in Bootstrap 5.3."}

```json ⏎ {"answer": "text-danger", "explanation": "Both classes have equal specificity, so the one defined later in Bootstrap's CSS wins; in the default $theme-colors map, 'danger' comes after 'primary', making .text-danger the last rule applied."} ⏎ ```

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

```json ⏎ {"answer": 3, "explanation": "The Domain class depends on Application (PlaceOrder) and Infrastructure (Db, Logger) — all three are violations since Domain can only depend on Domain."} ⏎ ```

{"answer": "10,15", "explanation": "$a->amount is 10, and $c is a new Money with 10+5=15, so the echo concatenates '10,15'."}

```json ⏎ {"answer": 1, "explanation": "The remove() method throws a DomainException before unsetting the item, so the items array still contains one element when count() is called."} ⏎ ```

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

{"answer": "yesno", "explanation": "The lazy ghost is uninitialized before property access (yes), and after $o->v triggers the initializer, it is no longer uninitialized (no)."}

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

{"answer":"noyes","explanation":"AnnotationClassLoader was removed in Symfony 7.0 (deprecated in 6.x), so it does not exist in 8.1, while AttributeClassLoader exists as its replacement."}