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

{"answer": "no", "explanation": "Double-quoted strings support variable interpolation and escape sequences (e.g., \\n, \\t), while single-quoted strings do not, so the processing is fundamentally different."}

{"answer": "yes", "explanation": "The null coalescing operator (??) is syntactic sugar for isset($var) ? $var : default, so it does not raise warnings for undefined variables."}

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

```json ⏎ {"answer": "yes", "explanation": "In PHP, print is a language construct that returns the value 1, and since it has a return value, it can be used within expressions (e.g., $x = 5 + print 'hello');"} ⏎ ```

{"answer": "no", "explanation": "The elvis operator ($a ?: $b) returns the left operand when it is truthy, not when it is falsy."}

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

{"answer": "no", "explanation": "The ** operator in PHP 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 2+3 is evaluated first to get 5, then concatenated with 'sum: '."}

{"answer": "no", "explanation": "With ===, arrays must have the same key-value pairs in the same order; with ==, order does not matter."}

{"answer":"no","explanation":"0 == false returns true because == is a loose comparison and false is cast to 0; it is not a strict comparison."}

{"answer": "no", "explanation": "In PHP 8, comparing a non-numeric string to an integer with == converts the integer to a string and compares them as strings, so \"abc\" == 0 evaluates to false (changed from PHP 7 behavior)."}

{"answer": "yes", "explanation": "Under PHP's loose comparison (==), null is equal to 0, the empty string \"\", and false, all simultaneously."}

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

{"answer": 10, "explanation": "PHP performs numeric addition when a numeric string is used with the + operator."}

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

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

{"answer":"no","explanation":"strrev() reverses a string byte-by-byte, which corrupts multi-byte UTF-8 characters; use mb_strrev() instead."}

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

{"answer": "no", "explanation": "str_pad() can pad on the right, left, or both sides via its third parameter (STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH)."}

{"answer": "no", "explanation": "By default trim() strips spaces, tabs, newlines, carriage returns, null bytes, and vertical tabs (\" \\t\\n\\r\\0\\x0B\"), not just spaces."}

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

{"answer": "def", "explanation": "substr with a negative start position counts from the end of the string, so -3 starts at the 3rd character from the end, returning 'def'."}

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

{"answer": "yes", "explanation": "Heredoc strings behave like double-quoted strings (variables are interpolated), while nowdoc strings behave like single-quoted strings (no interpolation)."}

{"answer": "no", "explanation": "sort() reindexes the array with sequential integer keys; use asort() to preserve key associations."}

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

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

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

{"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 with offset 1 and length 2 returns elements at index 1 and 2, which are 20 and 30."}

{"answer": 2, "explanation": "The + operator performs array union: it keeps left-side values and only adds right-side keys not already present, so key 'a' stays 1 and 'b' is added, giving 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 added support for the spread operator with arrays that have string keys in array literals, which was not allowed before."}

{"answer": "no", "explanation": "In PHP 8.0+, named arguments can be combined with the spread operator (...$args) in a single function call, e.g., foo(a: 1, ...$args)."}

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

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

{"answer": "no", "explanation": "Arrow functions (fn) in PHP always have a single expression body without curly braces; multiple statements require a regular closure with the function keyword."}

{"answer": "no", "explanation": "Arrow functions (fn) capture outer variables by value, not by reference; the capture is lazy (at call time), but it is still a by-value capture."}

{"answer": "yes", "explanation": "In PHP, declaring a closure as static explicitly prevents it from binding the current $this variable, even when defined inside a class method."}

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

{"answer": "yes", "explanation": "In weak typing mode (the default without strict_types=1), PHP coerces the numeric string \"5\" to the integer 5 when it is passed to an int-typed parameter."}

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

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

{"answer": "yes", "explanation": "In PHP, the final keyword on a method prevents it from being overridden in any subclass, and attempting to do so will cause a fatal error."}

{"answer": "no", "explanation": "In PHP, private properties are only accessible within the class that defines them, not in subclasses."}

{"answer": "class@anonymous", "explanation": "Anonymous classes in PHP have names like 'class@anonymous\\0/path/to/file:line', so the part before the NUL byte is 'class@anonymous'."}

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

{"answer":"no","explanation":"__get() is called for inaccessible properties, which includes both non-existent (undeclared) properties and private properties accessed from outside the class."}

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

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

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

{"answer": "no", "explanation": "PHP interfaces cannot declare static methods; all interface methods must be public and non-static, as implementing classes must provide an instance method implementation."}

{"answer": "no", "explanation": "The instanceof operator in PHP checks both class inheritance and interface implementation, so it will return true if an object's class implements the given interface."}

{"answer": "no", "explanation": "PHP interface methods must be abstract (no body); only traits can provide default method implementations."}

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

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

{"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) will not catch TypeError."}

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

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError exception in PHP when dividing by zero."}

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

{"answer": "no", "explanation": "An exception thrown in a finally block replaces any pending exception from the try/catch block, or causes one where none existed, thus changing the result."}

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

{"answer": "yes", "explanation": "register_shutdown_function() callbacks are executed when the script terminates, which includes normal completion, die(), and exit()."}

{"answer": "no", "explanation": "The use statement only creates a compile-time alias; the class file is not loaded until the class is actually referenced (e.g., via new or a static call), which triggers autoloading."}

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

{"answer":"Controller/Api/UserController.php","explanation":"PSR-4 maps the namespace App\\Controller\\Api to subdirectories Controller/Api/ and the class name UserController to UserController.php, giving the full relative path from src/."}

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

{"answer": "yes", "explanation": "__NAMESPACE__ is a magic constant 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 if not found there does PHP fall back to the global namespace."}

{"answer": "yes", "explanation": "PSR-4 maps the sub-namespace 'Model\\' to 'Model/' under the base directory 'src/', and the class name 'User' to 'User.php', resulting in src/Model/User.php."}

{"answer": "yes", "explanation": "PHP allows `use` statements inside function bodies, where they act as local aliases scoped to that function only."}

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

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

{"answer": "yes", "explanation": "In PHP, global variables are not automatically accessible within a function's local scope; they must be explicitly imported via the global keyword, $GLOBALS superglobal, or passed as parameters."}

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

{"answer": 6, "explanation": "The parameter is passed by reference, so the function modifies the original variable $n from 5 to 6."}

{"answer": "no", "explanation": "A foreach by value iterates over a snapshot of the array taken at the start of the loop; modifications to the array inside the loop do not affect the current pass."}

{"answer": "no", "explanation": "Static properties belong to the class, not to individual instances, so all instances share the same value and changes are visible across all of them."}

{"answer": "no", "explanation": "In PHP, boolean keys in arrays 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 can use `return` with a value, and that value can be retrieved via `$gen->getReturn()` after the generator is exhausted."}

{"answer": "no", "explanation": "Generators in PHP are single-use iterators; once fully consumed, calling rewind() throws a LogicException and they cannot be traversed again."}

{"answer": "yes", "explanation": "yield from (PHP 7.0+) delegates iteration to another generator or Traversable object, forwarding its values to the caller."}

{"answer": "Generator", "explanation": "g() is a generator function that returns a Generator object, and get_class() on a Generator instance returns the string \"Generator\"."}

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

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

{"answer": "yes", "explanation": "ArrayIterator is 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() automatically generates and embeds a salt in the returned hash; there is no salt parameter in its signature."}

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT is argon2id (not md5); md5 is not a supported algorithm for password_hash() at all."}

{"answer": "yes", "explanation": "password_verify() returns true when the given password matches the hash, and here 'secret' was used to generate the hash."}

{"answer":"no","explanation":"strip_tags() removes HTML/PHP tags and is relevant to XSS prevention, not SQL injection; SQL injection is mitigated by prepared statements or parameterized queries."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID, preventing an attacker from using a known session ID to hijack a user's authenticated session (session fixation)."}

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

{"answer": "yes", "explanation": "session_destroy() only destroys the server-side session data; the session cookie in the browser must be explicitly cleared with setcookie()."}

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

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

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

{"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 indicate that a function's return value should not be discarded."}

{"answer": "none", "explanation": "The pipe operator |> was proposed in an RFC but was never accepted or included in any stable PHP version."}

{"answer": "no", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) does not exist in any released version of PHP; it is not a real feature."}

{"answer": "no", "explanation": "array_first() and array_last() are not built-in PHP functions in any version; they exist only in libraries like Laravel's collections."}

```json ⏎ {"answer": "8.1", "explanation": "The RFC for first-class callable syntax (partial function application) was adopted for PHP 8.1."} ⏎ ```

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

{"answer": "no", "explanation": "As of the stated date, no 'Context Managers v2' RFC has been formally adopted in PHP; it remains in proposal or discussion stage."}

{"answer": "yes", "explanation": "The Bound-Erased Generic Types RFC was voted on and declined (rejected) by the PHP community."}

{"answer": "no", "explanation": "As of the available information, no RFC has been accepted to make ZTS (Zend Thread Safety) the default build in PHP; the default remains NTS."}

{"answer": "yes", "explanation": "PHP has never implemented native generics (parameterized types), and there is no accepted RFC to add them, so they remain absent as of PHP 8.5."}

{"answer": "yes", "explanation": "Following PHP's typical November release cadence, PHP 8.5 would have been released in late November 2025, making it the latest stable as of November 7, 2026, while PHP 8.6 is expected around November 19, 2026."}

{"answer": "yes", "explanation": "PHP 6 was planned but never released; the version numbering jumped from PHP 5.6 directly to PHP 7.0."}

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

{"answer": "yes", "explanation": "In Clean and Onion Architecture, the dependency rule mandates that dependencies always point inward toward the domain core, meaning inner layers have no knowledge of outer layers."}

{"answer": "yes", "explanation": "In DDD and clean architecture, domain entities are pure business objects that must not depend on frameworks or ORM providers, keeping the domain layer portable and framework-agnostic."}

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

{"answer": "Enterprise Core", "explanation": "The innermost layer of the onion architecture contains the Enterprise Core, which holds the domain entities and business rules."}

{"answer": "yes", "explanation": "Tools like deptrac are specifically designed to analyze and enforce layer dependencies, failing the build when a forbidden cross-layer call is detected."}

{"answer": "no", "explanation": "A use case (interactor) should be framework-agnostic and depend on abstract ports/interfaces, not concrete objects like an HTTP Request or EntityManager, to maintain testability and reusability."}

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

{"answer": "yes", "explanation": "In Clean Architecture, the dependency rule ensures inner layers (domain, use cases) have no knowledge of the database, so swapping it only affects the outer adapter layer."}

```json ⏎ {"answer": "no", "explanation": "An aggregate in DDD is a cluster of domain objects treated as a single consistency unit, not a database table; it is a domain modeling concept independent of persistence design."} ⏎ ```

{"answer": "yes", "explanation": "A Value Object, as defined in Domain-Driven Design, is immutable and its equality is determined by the equality of its field values rather than by object identity."}

{"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the Aggregate Root is the single entry point of an aggregate, ensuring all external modifications go through it to maintain invariants."}

{"answer": "yes", "explanation": "In DDD, a repository is defined per aggregate root, not per individual entity, to enforce the aggregate's consistency boundary and encapsulation."}

{"answer": "yes", "explanation": "Ubiquitous Language, a core concept from Domain-Driven Design, is the shared vocabulary used consistently by both developers and domain experts to communicate about the domain model."}

{"answer": "frame", "explanation": "In frame semantics, a frame is the contextual boundary within which a model and its language remain consistent, while outside it the same words map to different models."}

{"answer": "no", "explanation": "DDD advocates for rich domain models with behavior encapsulated in entities, while anemic models are considered an anti-pattern that pushes logic into services."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a Bounded Context ensures each context has its own domain model, so the same real-world concept can be modeled as different classes in different contexts."}

{"answer": "yes", "explanation": "Symfony's DI container instantiates services only when they are first requested via get(), rather than eagerly creating all services at boot time."}

{"answer": "debug:router", "explanation": "In Symfony, the command `bin/console debug:router` lists all registered routes."}

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

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes that extend Twig\\Template and caches them to avoid recompilation on subsequent requests."}

{"answer": "yes", "explanation": "In dev mode, Symfony caches the compiled container and only recompiles it when tracked files (config, service definitions, etc.) have changed, as determined by file timestamp/hash checks."}

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

{"answer": "no", "explanation": "Symfony controller action methods must be public, as the framework calls them from outside the class via the service container; a private method would result in an access error."}

{"answer": "no", "explanation": "Event subscribers are just a convenience for grouping listeners; dispatch order is determined by priority values, not by whether the handler is a subscriber or a listener."}

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

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute in Symfony checks a role or permission (via voter) on a controller method and throws a 403 AccessDeniedException if the user doesn't have it."}

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

{"answer": "yes", "explanation": "Symfony 7 requires PHP 8.2+ and has fully dropped doctrine/annotations in favor of native PHP attributes for validation constraints."}

{"answer": "yes", "explanation": "Symfony's framework bundle enables csrf_protection by default, so forms automatically include and validate a CSRF token on submission."}

{"answer": "yes", "explanation": "Symfony always validates form data server-side upon submission; client-side HTML5 validation is merely a UX convenience and can be bypassed."}

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

{"answer": "no", "explanation": "Symfony stores only the user's identifier (e.g., user ID or token) in the session, never the password."}

{"answer": "yes", "explanation": "Since Symfony 4.1, the recommended convention is to place configuration in config/packages/ with one file per bundle or topic (e.g., framework.yaml, doctrine.yaml)."}

{"answer": "yes", "explanation": "This is a standard best practice in PHP frameworks like Laravel and Symfony: .env holds safe dev defaults committed to git, while .env.local holds secrets and is git-ignored."}

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

{"answer": "no", "explanation": "The Symfony container is compiled and frozen before request handling, so calling setParameter() at runtime throws a LogicException."}

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

{"answer": "no", "explanation": "Many bundles have sensible defaults and work perfectly fine without any configuration file in config/packages; configuration is not mandatory for every bundle."}

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

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

{"answer": "no", "explanation": "In Symfony Messenger, a single message can be handled by multiple handlers; all matching handlers are invoked sequentially unless a handler stops propagation."}

{"answer": "no", "explanation": "The sync transport dispatches the message immediately in the same process without queuing it for a worker."}

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

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

{"answer": "yes", "explanation": "Symfony Messenger uses the Symfony Serializer component by default, which serializes messages to JSON format."}

{"answer": "yes", "explanation": "Symfony Scheduler defines schedulable messages that are produced at their scheduled times and dispatched through the Symfony Messenger component."}

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

{"answer": "yes", "explanation": "Symfony Messenger allows you to add custom middleware to the pipeline and control their position relative to built-in middleware via the transport configuration array order."}

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

{"answer": 8.4, "explanation": "Symfony 8 requires PHP 8.4 as its minimum supported version."}

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

{"answer": "yes", "explanation": "Symfony's AssetMapper component manages CSS/JS assets via an importmap.php file, eliminating the need for Node.js or webpack."}

{"answer": "no", "explanation": "Symfony 6.4 is actually a Long-Term Support (LTS) release, not a regular minor release."}

{"answer": "yes", "explanation": "Symfony follows a two-major-version deprecation cycle: a feature deprecated in version N still works (with warnings) in version N+1 and is typically only removed in N+2."}

{"answer": "yes", "explanation": "Symfony maintains UPGRADE files in its repository for each major release, listing removed deprecated features and breaking changes."}

{"answer": "AssetMapper", "explanation": "Symfony's AssetMapper component (symfony/asset-mapper) manages frontend assets and importmaps without requiring Node.js or webpack."}

{"answer": "yes", "explanation": "Following Symfony's release cadence (minor versions every 6 months in May and November), Symfony 8.2 is expected in November 2026, and releases typically occur in the first days of the month, so it would already be out by November 7."}

{"answer": "no", "explanation": "Following the six-month cycle, Symfony 8.0 is expected in November 2026, while Symfony 8.2 would be around May 2027."}

```json ⏎ {"answer": "8.2", "explanation": "Following Symfony's versioning pattern where minor versions increment sequentially (8.0, 8.1, 8.2, ...), the version after 8.1 is 8.2."} ⏎ ```

{"answer": "no", "explanation": "Symfony 8.2 does not exist, and even major Symfony releases provide upgrade paths rather than requiring full rewrites."}

{"answer": "yes", "explanation": "PHP's backward compatibility policy guarantees that minor version upgrades (e.g., 8.1 → 8.2) will not break existing code."}

{"answer": 8.4, "explanation": "Following Symfony's release pattern where each major branch ends at .4 (the LTS version), the last minor release of 8.x before 9.0 is 8.4."}

{"answer": "no", "explanation": "Symfony 8.2 does not exist; as of the current release cycle, Symfony is on the 7.x line, and no such version with a PHP 8.5 requirement has been announced."}

{"answer": "yes", "explanation": "Symfony's deprecation policy keeps deprecations for at least two major versions, so those added in 8.x will only be removed in 10.0, not 9.0."}

{"answer": "no", "explanation": "Twig's {{ }} syntax uses its own expression language and does not allow calling arbitrary PHP code directly; this is by design for security and sandboxing."}

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

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

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

{"answer": "yes", "explanation": "In Laravel Blade, the |raw filter (e.g., {{ $value|raw }}) outputs the value without HTML escaping, equivalent to using {!! !!}. "}

{"answer": "yes", "explanation": "In Twig, {{ }} outputs expressions (variables, function calls) and {% %} executes structural tags like if, for, and set."}

{"answer": "no", "explanation": "Twig allows declaring variables inside a template using the {% set %} tag, e.g. {% set name = 'value' %}."}

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

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

{"answer": "container", "explanation": "The .container class 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 modern versions use CSS Flexbox rather than floats."}

{"answer": "yes", "explanation": "Bootstrap 5 defines five breakpoints: sm (576px), md (768px), lg (992px), xl (1200px), and xxl (1400px)."}

{"answer":"no","explanation":"The number is an index into the spacing scale, not a direct multiplier of $spacer (e.g., .mt-3 = 1rem, not 3 × $spacer)."}

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

{"answer": "yes", "explanation": "Bootstrap 5 removed the jQuery dependency entirely and rewrote all its interactive components in vanilla JavaScript."}

{"answer": "no", "explanation": "Bootstrap 5 enables dark mode 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; schema management is handled explicitly via migrations or the SchemaTool."}

{"answer": "persist()", "explanation": "EntityManager::persist() marks a new entity as managed, deferring the actual SQL INSERT until flush() is called."}

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

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is an object-oriented query language that references entity classes and their mapped fields, which Doctrine then translates into SQL with actual table and column names."}

{"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 pending changes."}

{"answer": "yes", "explanation": "The Unit of Work tracks property changes on managed entities and will issue UPDATE statements on flush() without requiring an additional persist() call."}

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

{"answer": "no", "explanation": "MVCC is precisely the mechanism that allows readers and writers to operate concurrently without blocking each other; readers see old versions while writers create new ones."}

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

```json ⏎ {"answer": "no", "explanation": "SERIAL is a PostgreSQL-specific convenience that creates a separate sequence object with a default, while GENERATED AS IDENTITY is a SQL-standard column constraint with different semantics (e.g., OVERRIDING SYSTEM VALUE) and no separate user-manageable sequence object."} ⏎ ```

{"answer": "no", "explanation": "In PostgreSQL, NULL values are considered distinct from each other in a UNIQUE constraint, so multiple rows can have NULL in that column."}

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

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

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

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

{"answer": "yes", "explanation": "PostgreSQL operates in autocommit mode by default, meaning each individual SQL statement is automatically committed upon successful completion unless an explicit transaction is started with BEGIN."}

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

{"answer": "yes", "explanation": "Indexes are used by the database engine to locate rows for all DML operations (SELECT, UPDATE, DELETE), not just SELECT."}

{"answer": "yes", "explanation": "PostgreSQL uses SAVEPOINT to allow rolling back to a specific point within a transaction without aborting the entire transaction."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and provides actual execution statistics, while plain EXPLAIN shows the plan without executing."}

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

{"answer": "yes", "explanation": "A partial index in PostgreSQL is created with a WHERE clause and only includes rows that satisfy the given condition, reducing index size and improving query performance for those specific rows."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which detects serialization anomalies at commit time rather than by locking read rows."}

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

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

{"answer": "yes", "explanation": "Per RFC 9110, DELETE is defined as an idempotent method: multiple invocations have the same effect as a single invocation."}

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

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests is specifically defined for indicating that a client has sent too many requests in a given time period, i.e., rate limiting."}

{"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 of the request or response body."}

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not idempotent by default, whereas PUT is idempotent by definition in the HTTP specification."}

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

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

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

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

{"answer":"no","explanation":"XSS is primarily prevented by output encoding (context-aware encoding when rendering data in HTML), not by input validation before storage; input validation is a defense-in-depth measure but not the primary XSS defense."}

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

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

{"answer":"no","explanation":"A salt does not need to be secret; it is typically stored alongside the hash (e.g., in bcrypt's output) and its purpose is to prevent rainbow table attacks, not to add secrecy."}

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

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

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

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

{"answer": "no", "explanation": "It's the opposite: a stub returns predefined data, while a mock verifies that expected methods were called."}

{"answer": "yes", "explanation": "In PHPUnit 10+, PHP 8 attributes like #[DataProvider] are the recommended approach, and docblock annotations like @dataProvider are deprecated."}

{"answer": "no", "explanation": "PHPUnit provides the @depends annotation and the depends() method, allowing one test to depend on the result of another, though it is generally discouraged as a practice."}

{"answer": "--random-order", "explanation": "The --random-order flag in PHPUnit causes test cases to be executed in a random order rather than their default sequential order."}

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

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

{"answer": "true", "explanation": "Both '1e1' and '10' are numeric strings, so PHP compares them as numbers: 1e1 equals 10, making the comparison true."}

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

```json ⏎ {"answer": "2c", "explanation": "strtr with an array replaces the longest matching key first, so 'ab' is matched and replaced with '2' before 'a' could match, leaving 'c' unchanged."} ⏎ ```

{"answer": "[]", "explanation": "A negative offset of -10 on a 5-character string starts before the beginning, so substr returns an empty string."}

{"answer": "k,n,m", "explanation": "The array union operator (+) keeps left array keys and only adds right array keys not already present, so keys are k, n, m."}

{"answer": "yxz", "explanation": "usort sorts sub-arrays by their 3rd element (index 2) ascending, yielding [2,'y',1], [1,'x',2], [3,'z',2]; array_column extracts index 1 ('y','x','z') and implode concatenates them into 'yxz'."}

{"answer": 4, "explanation": "The spread operator with string keys produces named arguments, so $a=5 and $b=1 regardless of order, giving 5-1=4."}

```json ⏎ {"answer": 3, "explanation": "The first-class callable $f = $p->g(...) captures a reference to the object, so setting $p = null doesn't destroy the object, and calling $f() still returns $v = 3."} ⏎ ```

{"answer": "B", "explanation": "static::class uses late static binding, resolving to the actual class of the instance (B) rather than the defining class (A)."}

```json ⏎ {"answer": "fatal error", "explanation": "Assigning to $this->x inside its own setter triggers the setter recursively, causing infinite recursion and a fatal error (maximum function nesting level reached)."} ⏎ ```

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

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

{"answer": 2, "explanation": "In PHP, a return statement in a finally block overrides the return value from the try block, so the function returns 2."}

```json ⏎ {"answer": "second", "explanation": "A throw in a finally block replaces the in-flight RuntimeException, so the LogicException('second') propagates to the outer catch and its message is printed."} ⏎ ```

{"answer": "App\\Foo|Baz", "explanation": "Baz::class resolves to the aliased App\\Foo, while \\Baz::class resolves to the global Baz class."}

```json ⏎ {"answer": "yesyes", "explanation": "class_exists('Foo') resolves to Ns\\Foo (which exists), and class_exists('Ns\\Foo') also finds the class, so both ternaries return 'yes'."} ⏎ ```

{"answer": "1,2,99", "explanation": "After the by-reference foreach loop, $v remains a reference to the last element of $a, so assigning $v = 99 modifies $a[2]."}

{"answer": 3, "explanation": "Static variables in PHP are shared per class (not per instance), so all calls to inc() across instances of A and B increment the same $n: 1, 2, then 3 is echoed."}

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

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

```json ⏎ {"answer": "noyes", "explanation": "The first call returns false (hash already matches cost 4), the second returns true (cost differs, so rehash is needed)."} ⏎ ```

```json ⏎ {"answer": "strict-out", "explanation": "E_STRICT (2048) was deprecated in PHP 8.0 and removed from E_ALL by PHP 8.5, so E_ALL & 2048 equals 0."} ⏎ ```

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

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

```json ⏎ {"answer": "same", "explanation": "EntityManager::find() checks the identity map first and returns the same managed instance if the entity with that ID is already present, so both $a and $b reference the identical object."} ⏎ ```

```json ⏎ {"answer": 0, "explanation": "Persisting and then removing an entity before the first flush causes Doctrine to cancel both the insert and delete, so the row is never written to the table."} ⏎ ```

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

{"answer": "10,30,60", "explanation": "The window function sum(x) OVER (ORDER BY id) produces a running total (10, 30, 60), and string_agg concatenates them as text separated by commas."}

```json ⏎ {"answer": "M1M2", "explanation": "Each middleware echoes its tag before delegating to the next in the stack, so M1 then M2 are printed in order."} ⏎ ```

```json ⏎ {"answer": 1, "explanation": "HandleMessageMiddleware calls only the first matching handler from the HandlersLocator, so only $d1 (n += 1) executes."} ⏎ ```

{"answer": 1, "explanation": "The first INSERT succeeds, the second is skipped due to the unique constraint with ON CONFLICT DO NOTHING, so the table contains one row."}

{"answer": 2, "explanation": "The UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, so duplicate values are allowed within the transaction and only checked at commit time, meaning both INSERTs succeed and count returns 2."}

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

{"answer": "2, 1", "explanation": "The data provider supplies two sets (1 and -1), so 2 tests run; the assertion $x > 0 passes for 1 but fails for -1, giving 1 failure."}

{"answer": "POST", "explanation": "The -d flag causes curl to send a POST request by default."}

{"answer": "GET", "explanation": "The -G flag combined with -d causes curl to append the data as a query string and use the GET method instead of the default POST."}

{"answer": "invalid_client", "explanation": "RFC 6749 Section 5.2 defines 'invalid_client' as the error returned when the client identifier is missing or invalid (i.e., does not correspond to a known client)."}

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

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

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

{"answer": 0, "explanation": "Assert\\NotBlank checks if an array is empty (count 0), but [''] has one element so it passes validation, resulting in 0 violations."}

```json ⏎ {"answer": "invalid", "explanation": "The form was never submitted, so isValid() returns false (it does not throw), printing 'invalid'."} ⏎ ```

{"answer": "same", "explanation": "Symfony DI services are shared (singleton) by default, so each get() call returns the same instance, making the spl_object_id values equal."}

{"answer": "hi Bob!", "explanation": "During compilation, Symfony resolves nested parameter references: %greeting%! becomes 'hi Bob!' because %greeting% resolves to 'hi Bob' (which itself resolved %name% to 'Bob')."}

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

{"answer": "text-danger", "explanation": "In Bootstrap 5.3, text-danger is defined after text-primary in the CSS, so with equal specificity it wins by source order."}

{"answer": 2, "explanation": "The class is in the Domain layer but depends on both Application (PlaceOrder) and Infrastructure (Db), each of which violates 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 of which violate the rule that Domain may only depend on Domain."} ⏎ ```

{"answer": "10,15", "explanation": "$a has amount 10, and $c is a new Money object with 10+5=15, so the output is '10,15'."}

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

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

{"answer": "yesno", "explanation": "A lazy ghost object is uninitialized until a property is accessed; the first check returns 'yes', then accessing $o->v triggers initialization, so the second check returns 'no'."}

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

{"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 7.0+, while AttributeClassLoader (introduced as its replacement in 5.3) still exists in 8.1."}