Карта знаний PHP — anthropic/claude-haiku-5.5, run-08 · think: low

{"answer": "no", "explanation": "Double-quoted strings process escape sequences like \\n and interpolate variables, while single-quoted strings do not (except for \\' and \\\\)."}

{"answer": "yes", "explanation": "The ?? operator uses isset() semantics internally, so undefined variables, array keys, and properties produce no notice or warning and simply fall through to the right-hand value."}

{"answer": "ab", "explanation": "PHP's echo accepts multiple comma-separated arguments and outputs each in order with no separator, so 'a' and 'b' print as ab."}

{"answer": "yes", "explanation": "In PHP, print is a language construct that always returns 1, so it can be used within expressions, unlike echo."}

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

{"answer": "yes", "explanation": "PHP 8 lowered the precedence of the concatenation operator, so + and - now bind tighter than '.'."}

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

{"answer": "sum: 5", "explanation": "In PHP 8, the + operator binds tighter than the . concatenation operator, so 2 + 3 is evaluated first as 5, then concatenated onto 'sum: '."}

{"answer": "no", "explanation": "With ===, arrays are equal only if they have the same key/value pairs in the same order and of the same types; with == element order doesn't matter."}

{"answer": "no", "explanation": "0 == false is a loose comparison that performs type juggling and returns true; a strict comparison (===) would return false because the types differ."}

{"answer": "no", "explanation": "PHP 8 changed string-to-number comparison: a non-numeric string like \"abc\" is compared as a string with 0, so \"abc\" == 0 is false."}

{"answer": "yes", "explanation": "In PHP, null == 0, null == \"\", and null == false all evaluate to true under loose comparison, even though 0 == \"\" is false in PHP 8."}

{"answer": 42, "explanation": "PHP's integer cast of a string reads the leading numeric portion and ignores the trailing non-numeric characters, so '42abc' becomes 42."}

{"answer": 10, "explanation": "In PHP, the arithmetic operator converts the numeric string '5' to an integer, so 5 + 5 equals 10."}

{"answer": "no", "explanation": "In PHP, casting false to a string yields an empty string \"\", not \"0\"; it's true that null and false both become \"\", while true becomes \"1\"."}

{"answer": "yes", "explanation": "In PHP, 0.1 + 0.2 evaluates to approximately 0.30000000000000004 due to binary floating-point representation, so the strict comparison with 0.3 returns false."}

{"answer": "no", "explanation": "strrev() reverses a string byte by byte, so multibyte UTF-8 characters get broken into invalid sequences."}

{"answer": "yes", "explanation": "str_contains() returns true when the needle 'world' is found within the haystack 'Hello world'."}

{"answer": "no", "explanation": "str_pad() accepts STR_PAD_RIGHT (the default), STR_PAD_LEFT, and STR_PAD_BOTH, so it can pad on the left or both sides."}

{"answer": "no", "explanation": "PHP's trim() strips spaces, tabs, newlines, carriage returns, NUL bytes, and vertical tabs by default, not just spaces."}

{"answer": 6, "explanation": "PHP's strlen counts bytes, and 'é' is two bytes in UTF-8, so 'héllo' (5 characters) has 6 bytes."}

{"answer": "def", "explanation": "A negative start position counts from the end of the string, so -3 begins at the third-last character, returning the last three characters."}

{"answer": "no", "explanation": "PHP's ucfirst() returns a new string with the first character uppercased and does not modify the original argument in place."}

{"answer": "yes", "explanation": "Heredoc strings behave like double-quoted strings and interpolate variables, while nowdoc strings are like single-quoted strings and do not."}

{"answer": "no", "explanation": "PHP's sort() removes the existing keys and reindexes the array with sequential numeric keys; asort() or uasort() preserve key associations."}

{"answer": "yes", "explanation": "PHP converts canonical decimal integer strings used as array keys into integers, so '5' is stored as the integer key 5."}

{"answer": "no", "explanation": "in_array() uses loose comparison (==) by default; strict comparison requires passing true as the third argument."}

{"answer": "yes", "explanation": "Without a callback, array_filter() keeps only elements that evaluate to true, so falsy values such as 0, '', null, false, and empty arrays are removed."}

{"answer": "no", "explanation": "By default, array_slice() reindexes numeric keys starting from 0; the preserve_keys parameter defaults to false and must be set to true to keep the original numeric keys."}

{"answer": "[20, 30]", "explanation": "array_slice starts at index 1 and takes 2 elements, giving the array [20, 30] (re-indexed as keys 0 and 1)."}

{"answer": 2, "explanation": "The + operator takes the union: key 'a' keeps the left value 1, and only the missing key 'b' is added, giving two elements."}

{"answer": "yes", "explanation": "PHP 8.1 added support for unpacking arrays with string keys using the spread operator in array literals, where later string keys overwrite earlier ones."}

{"answer": "no", "explanation": "PHP allows named arguments after an unpacked `...$args` in the same call, for example `f(...$a, name: 1)`. Only unpacking placed after a named argument is disallowed."}

{"answer": "no", "explanation": "An anonymous function without a use clause cannot access variables from the enclosing scope; they are undefined inside it unless imported with use or accessed as superglobals."}

{"answer": 3, "explanation": "func_num_args() returns the number of arguments passed to the function, which is 3 here even though only one parameter is declared."}

{"answer": "no", "explanation": "PHP arrow functions (fn) only accept a single expression after the arrow, with no curly-brace body; a braced body is a syntax error."}

{"answer": "no", "explanation": "PHP arrow functions capture outer variables by value at the moment the function is created, not by reference or lazily at call time."}

{"answer": "yes", "explanation": "A static closure cannot bind $this automatically from its enclosing scope, so it does not capture $this and attempting to use $this inside it causes an error."}

{"answer": 5, "explanation": "The closure captures $x by value at creation time (when $x was 5), so later changing $x to 7 does not affect the captured value."}

{"answer": "yes", "explanation": "Without declare(strict_types=1), PHP's coercive typing mode converts the numeric string \"5\" to the integer 5 when passed to an int parameter."}

{"answer": "yes", "explanation": "Constructor property promotion, introduced in PHP 8.0, lets you declare and assign class properties directly in the constructor parameter list using visibility modifiers."}

{"answer": "final", "explanation": "Declaring a method as final prevents child classes from overriding it."}

{"answer": "yes", "explanation": "Declaring a method final prevents any subclass from overriding it, and PHP raises a fatal error if an override is attempted."}

{"answer": "no", "explanation": "Private properties are only accessible within the class that declares them, so a subclass cannot access a parent's private property directly."}

{"answer": "class@anonymous", "explanation": "PHP names anonymous classes \"class@anonymous\" followed by a NUL byte and the file path and line, so the part before the NUL is \"class@anonymous\"."}

{"answer": "yes", "explanation": "In PHP, private methods are not part of the inheritance contract, so a child class can declare a method with the same name and any visibility without it being treated as an override."}

{"answer": "no", "explanation": "__get() is also called when accessing inaccessible properties, such as private or protected ones from outside the class scope, not only non-existent ones."}

{"answer": "Error", "explanation": "Reassigning an initialized readonly property throws an Error (Error: Cannot modify readonly property), not an Exception."}

{"answer": "yes", "explanation": "PHP interfaces can declare constants, which implementing classes inherit and can access but not override (before PHP 8.1 overriding was disallowed; from 8.1 final constants can prevent overriding)."}

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

{"answer": "yes", "explanation": "PHP interfaces can declare static methods, and implementing classes must provide them with a compatible signature."}

{"answer": "no", "explanation": "PHP's instanceof operator also returns true when an object's class implements the interface being checked, not just when it inherits from a class."}

{"answer": "no", "explanation": "PHP interface methods must be declared without a body; only traits can provide default implementations, and interfaces cannot contain method bodies."}

{"answer": "yes", "explanation": "Abstract methods may be declared public or protected, but not private, since subclasses must be able to see and implement them."}

{"answer": 3, "explanation": "Foo::cases() returns an array containing one element for each declared case, and this enum declares three cases (A, B, C)."}

{"answer": "yes", "explanation": "Traits could not declare constants before PHP 8.2, but PHP 8.2 added support for constants in traits."}

{"answer": "yes", "explanation": "In PHP 7 and later, Throwable is an interface implemented by both the Exception and Error classes, making it their common ancestor."}

{"answer": "no", "explanation": "TypeError implements the Throwable interface and extends Error, not Exception, so catch (Exception $e) does not catch it."}

{"answer": "no", "explanation": "The @ operator only temporarily sets error_reporting to suppress non-fatal errors like warnings and notices; it does not catch or suppress thrown exceptions."}

{"answer": "DivisionByZeroError", "explanation": "intdiv() throws a DivisionByZeroError when the divisor is zero, as it is an Error subclass rather than a warning."}

{"answer": "no", "explanation": "In PHP, the finally block runs whether or not an exception was thrown or caught, including when there is no catch block or when the exception goes uncaught."}

{"answer": "no", "explanation": "An exception thrown in a finally block replaces the try block's outcome, discarding any pending return value or exception from the try block."}

Objects cast to bool are always true in PHP, regardless of their contents. So the result is true, which as a yes/no answer is "yes". ⏎  ⏎ {"answer": "yes", "explanation": "Any object cast to bool evaluates to true in PHP, so casting a new Exception object yields true."}

{"answer": "yes", "explanation": "Shutdown functions run after the script finishes, including when it terminates early via exit() or die(), as well as after fatal errors."}

{"answer": "no", "explanation": "A use statement only creates an alias for a class name at compile time; it does not load or autoload the class file, which happens only when the class is actually referenced at runtime."}

{"answer": "function", "explanation": "PHP's 'use function' statement imports a function name into the current namespace, while 'use const' imports constants and plain 'use' imports classes."}

PSR-4 maps the namespace prefix App\ to src/, so the remaining namespace segments become directories: Controller\Api\UserController maps to Controller/Api/UserController.php. ⏎  ⏎ {"answer": "src/Controller/Api/UserController.php", "explanation": "PSR-4 replaces the App\\ prefix with src/ and converts the remaining namespace separators to directory separators, appending .php to the class name."}

{"answer": "no", "explanation": "Including vendor/autoload.php does not itself register autoloaders; it loads Composer's autoload.php, which typically calls spl_autoload_register() indirectly through ClassLoader, so the statement as phrased is misleading and the answer is false."}

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

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

{"answer": "yes", "explanation": "PSR-4 maps the namespace prefix App\\ to the src/ directory, so the remaining namespace segment Model\\User becomes the path src/Model/User.php."}

{"answer": "no", "explanation": "In PHP, `use` imports are only permitted at the top level of a file or inside a namespace block, not inside function bodies (closures use a separate `use` clause for variable binding)."}

{"answer": "yes", "explanation": "In PHP, arrays are assigned by value, so assigning an array to another variable creates a copy unless the reference operator & is used."}

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

{"answer": "yes", "explanation": "In PHP, global variables are not visible inside functions by default, so they must be accessed via the global keyword, the $GLOBALS array, or passed as parameters."}

{"answer": "no", "explanation": "In PHP, unset($GLOBALS['x']) inside a function removes the global variable itself for everyone, not just within that function's scope."}

{"answer": 6, "explanation": "The parameter $x is passed by reference, so incrementing it inside inc() changes the original variable $n from 5 to 6."}

{"answer": "no", "explanation": "A foreach by value iterates over a copy of the array (the original array's internal pointer is not used), so changes made to the array inside the loop are not seen during that pass."}

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

{"answer": "no", "explanation": "PHP casts boolean array keys to integers, so true is stored as the integer key 1, not as a boolean."}

{"answer": "yes", "explanation": "Since PHP 7.0, a generator can use return with a value, which is retrieved after completion with $gen->getReturn()."}

{"answer": "no", "explanation": "PHP generators cannot be rewound after they have advanced past the first yield; calling rewind() then throws an Exception saying the generator cannot be rewound after it has already been iterated."}

{"answer": "yes", "explanation": "The yield from expression delegates iteration to a sub-generator or any iterable, passing its values through to the caller."}

Calling a generator function returns an object of class Generator, so get_class returns "Generator". ⏎  ⏎ {"answer": "Generator", "explanation": "Calling a function containing yield returns an instance of the built-in Generator class."}

{"answer": 3, "explanation": "The generator uses `yield from [1, 2, 3]`, which yields three values with keys 0, 1, 2, so iterator_to_array returns an array of three elements."}

{"answer": "no", "explanation": "SplStack is a LIFO (last in, first out) structure; SplQueue is the SPL class that implements FIFO behavior."}

{"answer": "yes", "explanation": "ArrayIterator implements the SeekableIterator, Iterator, Traversable, and related interfaces, letting you wrap an array and iterate over it with foreach or Iterator methods."}

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

{"answer": "yes", "explanation": "PHP's password_hash() automatically generates a cryptographically secure random salt and embeds it in the resulting hash, so no separate salt needed."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT currently refers to the bcrypt algorithm (PASSWORD_BCRYPT), not MD5, and it automatically generates a salt."}

{"answer": "yes", "explanation": "password_hash creates a salted hash of 'secret', and password_verify checks the plaintext against that hash, returning true."}

{"answer": "no", "explanation": "strip_tags() removes HTML and PHP tags and does not protect against SQL injection; prepared statements or parameterized queries are the proper defense."}

{"answer": "yes", "explanation": "Calling session_regenerate_id() after login issues a new session ID, preventing attackers from reusing a fixated session ID obtained before authentication."}

{"answer": "php_sapi_name", "explanation": "php_sapi_name() returns the server API (SAPI) name the PHP process is running under, such as \"cli\" or \"apache2handler\"."}

{"answer": "yes", "explanation": "session_destroy() removes the session data on the server, but the session cookie stays in the browser and must be expired separately, for example with setcookie()."}

{"answer": "no", "explanation": "Without session_start() (or session.auto_start enabled), PHP does not load session data, so $_SESSION is not populated."}

{"answer": "8.4", "explanation": "array_find() was added in PHP 8.4 as part of the new array search helpers alongside array_find_key(), array_any() and array_all()."}

{"answer": "yes", "explanation": "Property hooks, which let get and set logic be declared directly in the property declaration, were introduced in PHP 8.4."}

{"answer": "yes", "explanation": "PHP 8.4 introduced asymmetric visibility, allowing separate read and write visibility modifiers such as public private(set) on properties."}

{"answer": "8.5", "explanation": "The #[\\NoDiscard] attribute, which warns when a function's return value is ignored, was added in PHP 8.5."}

{"answer": "8.5", "explanation": "The pipe operator |> was not in PHP 8.4 and was added in PHP 8.5 after its RFC was accepted for that release."}

{"answer": "8.5", "explanation": "The clone-with syntax was added in PHP 8.5, which accepts an array of property overrides as the second argument to clone."}

{"answer": "8.5", "explanation": "array_first() and array_last() were added in PHP 8.5 after their RFC was accepted, and they are not available in earlier versions."}

{"answer": "none", "explanation": "The Partial Function Application v2 RFC was not adopted into any PHP version; it was declined and never implemented."}

{"answer": 8.5, "explanation": "The clamp() function from the clamp_v2 RFC is, to my best recollection, part of PHP 8.5, but I'm not certain of this."}

{"answer": "no", "explanation": "I have no record of a 'Context Managers v2' RFC being adopted into PHP, and I can't verify events up to the stated date of 2026-11-07."}

{"answer": "no", "explanation": "I have no record of a 'Bound-Erased Generic Types' RFC being declined in 2026, so I can't confirm this statement as true."}

{"answer": "no", "explanation": "As far as I know, no RFC making ZTS (thread-safe builds) the default has been accepted; NTS remains the default, and I can't confirm events after my knowledge cutoff."}

{"answer": "yes", "explanation": "PHP 8.5 does not add generics; PHP still lacks native parameterized types, which remain only a proposed idea."}

{"answer": "yes", "explanation": "PHP 8.5 was released in November 2025, and the stated 8.6 GA date of 2026-11-19 falls after 2026-11-07, so the claim is consistent, though I can't verify the 8.6 date."}

{"answer": "yes", "explanation": "PHP 6 was developed but abandoned due to Unicode-related difficulties and was never released; the next major version after 5.6 was PHP 7.0."}

{"answer": "yes", "explanation": "The Deprecated attribute RFC was accepted and shipped in PHP 8.4, letting code mark functions, methods, and constants as deprecated."}

{"answer": "yes", "explanation": "In clean and onion architectures, source code dependencies point inward toward the domain core, so inner layers have no knowledge of outer layers."}

{"answer": "yes", "explanation": "Domain entities should be framework-agnostic, depending only on PHP itself and possibly its standard library, with no Doctrine or Symfony imports."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (UI/infrastructure) layer, not the business-logic layer; they merely invoke use cases that live in the domain/application layer."}

{"answer": "Domain model", "explanation": "In onion architecture, the domain model (entities and value objects) forms the innermost core, with other layers wrapping around it."}

{"answer": "yes", "explanation": "Tools like deptrac analyze class dependencies against configured layer rules and report or fail the build when a forbidden dependency between layers occurs."}

{"answer": "no", "explanation": "In clean architecture, use cases should not depend on framework or infrastructure concerns like HTTP requests or EntityManager; they should accept plain input data and depend on abstractions such as repository interfaces."}

{"answer": "Repository", "explanation": "A repository provides a collection-like interface for aggregates or entities while abstracting away the underlying persistence storage."}

{"answer": "yes", "explanation": "In clean architecture, the database is an outer-layer detail accessed through interfaces (ports) defined by inner layers, so changing it only affects the infrastructure adapters, not the domain or use cases."}

{"answer": "no", "explanation": "In Domain-Driven Design an aggregate is a cluster of domain objects treated as a single unit for data changes, with a root entity enforcing invariants; it is not the same as a database table."}

{"answer": "yes", "explanation": "A Value Object is defined by its attribute values rather than a unique identity, and it is immutable, so equality is based on field values."}

{"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the aggregate root is the single entry point through which all external changes to the aggregate must pass."}

{"answer": "yes", "explanation": "In Domain-Driven Design, repositories are provided per aggregate root only, since the root is the sole entry point for accessing and modifying objects within the aggregate."}

{"answer": "yes", "explanation": "In Domain-Driven Design, the ubiquitous language is a shared vocabulary used by both developers and domain experts, derived from and reflected in the domain model."}

{"answer": "domain of discourse", "explanation": "The domain of discourse is the range of objects over which a model's language is interpreted, so the same words can mean different things outside that domain. This is a best guess, as the question's wording is ambiguous."}

{"answer": "no", "explanation": "Domain-Driven Design advocates rich domain models where behavior and invariants live within entities and value objects, and an anemic model (getters/setters with logic in services) is widely considered an anti-pattern."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a bounded context delimits where a particular model applies, so the same real-world concept (e.g., a customer) can be modeled as different classes in different contexts."}

{"answer": "yes", "explanation": "The Symfony DI container instantiates a service only when it is first requested, unless it is explicitly marked as eager or synthetic, while the separate 'lazy' option (proxy-based) is off by default."}

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

{"answer": "no", "explanation": "Symfony's autowiring and autoconfiguration let services be registered automatically from the src/ directory via resource loading, so manually declaring every service is not required."}

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes, which are stored in a cache directory and reused across requests until the template changes (when auto_reload is enabled) or the cache is cleared."}

{"answer": "yes", "explanation": "With debug mode enabled in the dev environment, Symfony's ConfigCache checks the freshness of tracked resource files and rebuilds the container only when they change, not on every request."}

{"answer": "APP_ENV", "explanation": "Symfony reads the APP_ENV environment variable (typically set in .env) to determine the active environment such as dev or prod."}

{"answer": "no", "explanation": "Symfony invokes controller actions from outside the class, so the method must be public; private methods cannot be called by the router."}

{"answer": "no", "explanation": "Event subscribers are registered as ordinary listeners, and their invocation order is determined only by the priority values they declare, not by the interface itself."}

{"answer": "yes", "explanation": "Symfony 5.1 introduced the authenticator system based on AuthenticatorInterface, and the older Guard authenticators were removed in Symfony 6.0."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute (Symfony\\Component\\Security\\Http\\Attributes\\IsGranted) checks a role or permission on a controller and throws an access denied (403) exception if it fails."}

{"answer": "yes", "explanation": "Symfony voters evaluate whether a user has a given attribute (like EDIT) on a specific subject object, which is what isGranted('EDIT', $post) checks."}

{"answer": "yes", "explanation": "Symfony 7 reads validation constraints from PHP attributes, and support for Doctrine annotations has been removed from Symfony's components."}

{"answer": "yes", "explanation": "Symfony enables CSRF protection for forms by default, adding a hidden token field that is validated on submission."}

{"answer": "yes", "explanation": "Symfony's form validation constraints are enforced on the server when the form is submitted and validated, regardless of any client-side HTML5 checks, which can be bypassed."}

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

{"answer": "no", "explanation": "Symfony's security component stores only the user identifier (and serialized user data without the plain password) in the session, and passwords are hashed rather than kept in plain text."}

{"answer": "yes", "explanation": "Symfony stores bundle configuration in config/packages, typically with one YAML (or PHP/XML) file per bundle or topic, such as framework.yaml or doctrine.yaml."}

{"answer": "yes", "explanation": "This matches the common Symfony/Dotenv convention: .env holds committed defaults, while .env.local (ignored by git) holds machine-specific or secret values that override them."}

{"answer": "debug:container", "explanation": "The php bin/console debug:container command lists all registered services, including their aliases."}

{"answer": "no", "explanation": "Compiled Symfony container parameters are frozen and read-only at runtime, and controllers only get a service locator that has no setParameter() method."}

{"answer": "no", "explanation": "Since Symfony 4.0, services are private by default, so they cannot be fetched directly from the container unless marked public or accessed via service subscribers or tagged injection."}

{"answer": "no", "explanation": "Bundles work with default configuration; a config file in config/packages is optional and only needed to override defaults, and bundles without a configuration tree need no config at all."}

{"answer": "yes", "explanation": "Symfony's service configuration supports the %env(VAR)% syntax to inject environment variable values into services.yaml."}

{"answer": "APP_DEBUG", "explanation": "Symfony's APP_DEBUG environment variable toggles debug mode, which controls the profiler and Twig debugging behavior."}

{"answer": "no", "explanation": "In Symfony Messenger, a single message can be routed to multiple handlers, and each matching handler will receive and process it."}

{"answer": "no", "explanation": "The sync transport in Symfony Messenger handles messages immediately in the same process instead of queuing them for a worker."}

{"answer": "php bin/console messenger:consume", "explanation": "The Symfony Messenger component provides the messenger:consume command to start a worker that processes queued messages."}

{"answer": "yes", "explanation": "In Symfony Messenger, retry_strategy (max_retries, delay, multiplier, etc.) is set under each transport's configuration, so it applies per transport."}

{"answer": "yes", "explanation": "Symfony Messenger's default transport serializer uses the Symfony Serializer component and encodes messages as JSON, with PHP serialization available as an alternative."}

{"answer": "yes", "explanation": "Symfony Scheduler generates messages from RecurringMessage definitions at their scheduled times and dispatches them through the Messenger component's bus and transports."}

{"answer": "doctrine", "explanation": "Symfony Messenger's built-in Doctrine transport stores messages in a database table using Doctrine DBAL, selected via the doctrine:// DSN scheme."}

{"answer": "yes", "explanation": "Symfony Messenger buses accept custom middleware in their configured middleware list, and it can be positioned before or after the built-in middleware."}

{"answer": "yes", "explanation": "Symfony publishes a new major version every two years and minor versions every six months, in May and November."}

{"answer": "8.4", "explanation": "Symfony 8.0 requires PHP 8.4 or higher, as Symfony 7.4 LTS supports PHP 8.2 and later versions drop older PHP support."}

{"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations, so routes, validation and similar config must use PHP attributes, YAML, or XML instead."}

{"answer": "yes", "explanation": "Symfony's AssetMapper component serves and versions frontend assets directly from the filesystem, and uses the importmap.php file to map JavaScript module imports to asset paths, without requiring Node.js or Webpack."}

{"answer": "no", "explanation": "Symfony 6.4 is a long-term support (LTS) release, receiving bug fixes for three years and security fixes for four."}

{"answer": "no", "explanation": "Symfony's backward compatibility policy allows deprecated features to be removed in the next major version, so major releases do remove them."}

{"answer": "yes", "explanation": "Symfony publishes UPGRADE-x.0.md files in its repository for each major release, documenting breaking changes and how to migrate."}

{"answer": "AssetMapper", "explanation": "Symfony's AssetMapper component serves and versions assets and manages JavaScript importmaps without needing Node.js or Webpack."}

{"answer": "no", "explanation": "Symfony releases minor versions in May and November, so 8.0 arrives in May 2026, 8.1 in November 2026, and 8.2 not until May 2027."}

{"answer": "no", "explanation": "Symfony minor releases come out every May and November, so the November 2026 release should be 8.1, with 8.2 following in May 2027."}

{"answer": "8.2", "explanation": "Symfony minor releases are numbered sequentially within a major version, so the version after 8.1 is 8.2; the 8.x release schedule is an assumption here, not verified against the official roadmap."}

{"answer": "no", "explanation": "Symfony 8.2 would be a minor release, and Symfony only introduces breaking changes in major versions, so applications shouldn't need rewriting for it."}

```json ⏎ {"answer": "no", "explanation": "PHP 8.2 added deprecations (such as dynamic property creation and utf8_encode/utf8_decode) and some behavior changes, so code may need updates to avoid warnings or breakage."} ⏎ ```

{"answer": 4, "explanation": "Following Symfony's release cycle, the 8.x branch has minors 8.0 to 8.4, and 8.4 (the LTS) ships alongside 9.0, as 7.4 did with 8.0."}

{"answer": "no", "explanation": "Symfony only raises its minimum PHP version with major releases, so a 8.2 minor release would keep the PHP requirement set by 8.0 (PHP 8.4), not require PHP 8.5."}

{"answer": "yes", "explanation": "Symfony only removes deprecated features in major releases, so anything deprecated in 8.x stays available until 9.0 at the earliest."}

{"answer": "no", "explanation": "Twig expressions inside {{ }} use Twig's own syntax and can only call functions, filters, and methods that are explicitly exposed to the template, not arbitrary PHP code."}

{"answer": "yes", "explanation": "Twig's autoescape option is enabled by default, so printed variables are escaped for HTML context unless a filter like raw is applied."}

{"answer": "yes", "explanation": "The Twig `e` filter is an alias of `escape`, which by default escapes strings for the HTML context."}

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

{"answer": "yes", "explanation": "In Twig, the raw filter (like |raw) marks a value as safe so that auto-escaping is not applied to it."}

{"answer": "yes", "explanation": "In Twig, {{ }} outputs the value of an expression, while {% %} is used for tags such as conditions, loops, and set."}

{"answer": "no", "explanation": "Twig provides the `{% set %}` tag, which lets you declare and assign variables directly inside a template, not only pass them from the controller."}

{"answer": "dump", "explanation": "Twig's dump() function outputs debug information about a variable, such as its structure for arrays and objects, and requires the debug extension to be enabled."}

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS and JavaScript library providing prebuilt UI components, not a single-page application framework like React or Angular."}

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

{"answer": "no", "explanation": "Bootstrap's grid uses 12 columns, not 16, and since version 4 it is built on flexbox rather than floats."}

{"answer": "yes", "explanation": "Bootstrap 5 uses sm, md, lg, xl, and xxl as infixes in class names; the xs breakpoint has no infix, so those five are the named ones."}

{"answer": "no", "explanation": "The number is only an index into the scale; .mt-3 is $spacer × 1 and .px-2 is $spacer × 0.5, so the number itself is not a multiple of $spacer."}

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the data-bs-toggle attribute activates interactive components such as dropdowns, modals, and collapses on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 dropped its jQuery dependency and its components are implemented in vanilla JavaScript, so they work without jQuery."}

{"answer": "no", "explanation": "Bootstrap 5.3 enables dark mode with a data-bs-theme=\"dark\" attribute on the root element (or a component), not a .dark class."}

{"answer": "no", "explanation": "Doctrine ORM does not create tables at runtime; schema must be created or updated explicitly via tools like doctrine:schema:update or migrations."}

{"answer": "persist", "explanation": "EntityManager::persist() marks an entity as managed so it will be inserted on flush(), with no SQL executed until then."}

{"answer": "no", "explanation": "EntityManager::merge() was deprecated in Doctrine ORM 2.x and removed in ORM 3.0, so it no longer exists."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is object-oriented and references PHP entity classes and their properties rather than database tables and columns."}

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

{"answer": "no", "explanation": "Doctrine does not flush automatically; changes are persisted only when EntityManager::flush() is explicitly called (DoctrineBundle does not add an automatic flush at request end)."}

{"answer": "yes", "explanation": "Doctrine's Unit of Work tracks managed entities, so changes to them are detected and written on flush() without calling persist() again."}

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

{"answer": "no", "explanation": "PostgreSQL's MVCC means readers do not block writers and writers do not block readers, since readers see a consistent snapshot while writers create new row versions."}

{"answer": "EXPLAIN", "explanation": "EXPLAIN displays the query's execution plan without actually running the statement (unlike EXPLAIN ANALYZE, which executes it)."}

{"answer": "no", "explanation": "Both produce auto-incrementing values, but SERIAL is a shorthand that sets a DEFAULT nextval() on a separately owned sequence, while GENERATED AS IDENTITY is the SQL-standard construct with stricter insert rules and different sequence dependency handling."}

{"answer": "no", "explanation": "In PostgreSQL, NULL values are treated as distinct, so a default UNIQUE constraint allows multiple rows with NULL in the column; NULLS NOT DISTINCT (PostgreSQL 15+) is needed to restrict that."}

{"answer": "string_agg", "explanation": "PostgreSQL's string_agg(expression, delimiter) concatenates non-null input values into a single string separated by the given delimiter."}

{"answer": "no", "explanation": "Plain VACUUM marks space from dead tuples as reusable within the table but generally does not return it to the operating system; only VACUUM FULL or similar rewriting operations shrink the file."}

{"answer": "PARTITION BY", "explanation": "The PARTITION BY clause in an OVER() window definition divides the result set into groups over which the window function is computed."}

{"answer": "no", "explanation": "READ COMMITTED only prevents dirty reads; non-repeatable reads are prevented at REPEATABLE READ and stricter levels."}

{"answer": "yes", "explanation": "PostgreSQL runs each standalone SQL statement in its own implicit transaction and commits it automatically unless an explicit transaction block is used."}

{"answer": "COMMIT", "explanation": "The COMMIT statement ends the current transaction and makes all of its changes permanent."}

{"answer": "yes", "explanation": "UPDATE and DELETE statements that search on an indexed column can locate the affected rows faster via the index, just as SELECT does."}

{"answer": "yes", "explanation": "ROLLBACK TO SAVEPOINT undoes only the statements executed after the named savepoint while keeping the rest of the transaction open."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports real run times and row counts, whereas plain EXPLAIN only shows the estimated plan without running it."}

{"answer": "pgvector", "explanation": "The pgvector extension adds a vector data type and indexing (IVFFlat and HNSW) for similarity search over embeddings in PostgreSQL."}

{"answer": "yes", "explanation": "A partial index includes only the table rows that satisfy its WHERE predicate, which makes it smaller and cheaper to maintain."}

{"answer": "no", "explanation": "PostgreSQL's SERIALIZABLE level uses Serializable Snapshot Isolation, which tracks read dependencies with non-blocking predicate locks and aborts conflicting transactions, rather than locking the rows read."}

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

{"answer": 204, "explanation": "HTTP 204 No Content indicates the request succeeded and there is no content to return in the response body."}

{"answer": "yes", "explanation": "RFC 7231 defines DELETE as idempotent because repeated identical requests leave the server state the same, though the response code (e.g., 404 on a repeat) may differ."}

{"answer": "no", "explanation": "Access-Control-Allow-Origin is a response header sent by the server to tell the browser which origins may read the response; the client sends the Origin header, not this one."}

{"answer": "yes", "explanation": "HTTP status 429 Too Many Requests is defined in RFC 6585 and signals that the client has sent too many requests in a given time window, exceeding a rate limit."}

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

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

{"answer": "yes", "explanation": "RFC 5789 states that PATCH is neither safe nor idempotent, whereas PUT is defined as idempotent by RFC 7231."}

{"answer": "no", "explanation": "A plain == comparison can leak timing information, enabling timing attacks; use password_verify() for password hashes or hash_equals() for comparing hash strings."}

{"answer": "yes", "explanation": "A session-bound CSRF token generated by the server and checked on state-changing requests like POST is the standard defense against cross-site request forgery."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP response header enables and defines the Content Security Policy for a page."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol; access tokens grant access to resources and don't inherently identify the user (OpenID Connect adds the ID token for authentication)."}

{"answer": "no", "explanation": "XSS is prevented by context-aware output encoding/escaping when rendering data, not solely by validating input before storage, since data may reach output through other paths."}

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

{"answer": "yes", "explanation": "Refresh tokens are typically long-lived and are exchanged for new access tokens, so users don't have to re-authenticate each time the short-lived access token expires."}

{"answer": "no", "explanation": "Salts are stored alongside the hash and are not secret; they exist to defeat precomputed rainbow tables, and the hash can still be verified because the salt is read from storage."}

{"answer": "no", "explanation": "PHPUnit test classes must extend PHPUnit\\Framework\\TestCase, which provides the assertion methods and the lifecycle the runner relies on."}

{"answer": "no", "explanation": "PHPUnit's setUp() runs before each individual test method, not once before all tests in the class; setUpBeforeClass() is the method that runs once per class."}

{"answer": "no", "explanation": "A PHPUnit data provider supplies multiple argument sets, and the test runs once for each set, so it is not limited to exactly one."}

{"answer": "expectException", "explanation": "PHPUnit's expectException() method declares that the test is expected to throw an exception of the given class."}

{"answer": "no", "explanation": "It is reversed: a stub only returns canned data, while a mock additionally verifies that specific methods were called (expectations)."}

{"answer": "yes", "explanation": "PHPUnit 10 and later use the #[DataProvider] attribute, and the older @dataProvider docblock annotation is deprecated in favor of it."}

{"answer": "no", "explanation": "PHPUnit supports test dependencies via the @depends annotation (or #[Depends] attribute), which lets one test use the result of another."}

{"answer": "--order-by=random", "explanation": "PHPUnit's --order-by option with the random value runs tests in random order (also available via --random-order, which is an alias for random ordering in newer versions)."}

intdiv(7,2) = 3. intdiv(-7,2) truncates toward zero = -3. Concatenation gives "3" . "-3" = "3-3". ⏎  ⏎ {"answer": "3-3", "explanation": "intdiv truncates toward zero, so intdiv(7,2) is 3 and intdiv(-7,2) is -3, and concatenating gives \"3-3\"."}

In PHP, ** has higher precedence than unary minus, so -3 ** 2 is -(3 ** 2) = -9. ⏎  ⏎ {"answer": -9, "explanation": "The exponentiation operator binds tighter than unary minus, so it evaluates as -(3**2) = -9."}

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

{"answer": "other", "explanation": "In PHP 8, switch uses loose comparison, and 'a' == 0 is false because the non-numeric string is compared as the string \"0\", so the default branch runs."}

{"answer": "2c", "explanation": "When strtr is given an array, it replaces the longest matching key first, so 'ab' becomes '2' and the remaining 'c' is kept."}

{"answer": "[hello]", "explanation": "A negative start larger than the string length is clamped to 0, so substr returns the whole string 'hello', which is wrapped in brackets."}

{"answer": "k,n,m", "explanation": "The + operator keeps $a's keys first (k, n) and appends only the new key m from $b, since k already exists."}

{"answer": "yxz", "explanation": "usort sorts by the third element ascending, giving [2,'y',1], [1,'x',2], [3,'z',2]; PHP 8's sort is stable, so the tied entries keep their original order, and array_column then yields y, x, z."}

Spread with string keys maps to named parameters: a=5, b=1, so 5 - 1 = 4. ⏎  ⏎ {"answer": 4, "explanation": "String keys in an argument unpack are treated as named arguments, so a=5 and b=1, giving 5 - 1 = 4."}

{"answer": 3, "explanation": "The first-class callable `$p->g(...)` creates a Closure that holds a reference to the object, so setting `$p = null` does not destroy it and `$f()` still returns `$this->v`, which is 3."}

{"answer": "B", "explanation": "static::class resolves to the late static binding class of the called object, which is B, so it outputs B."}

{"answer": 10, "explanation": "Inside its own set hook, `$this->x` bypasses the hook and writes the backing value, so `$c->x = 5` stores 5*2 = 10, which is then echoed."}

{"answer": "BA", "explanation": "`TB::f insteadof TA` makes `f()` come from TB (returns 'B'), and `TA::f as g` creates an alias `g` for TA's method (returns 'A'), so the concatenation is 'BA'."}

{"answer": 0, "explanation": "Static properties declared in a trait are copied separately into each class that uses it, so setting CX::$n does not affect CY::$n, which stays at its default 0."}

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

{"answer": "second", "explanation": "The exception thrown in the finally block replaces the in-flight RuntimeException, so the outer catch receives the LogicException and echoes its message."}

{"answer": "App\\Foo|Baz", "explanation": "`Baz::class` resolves through the `use` alias to `App\\Foo`, while `\\Baz::class` is the fully qualified global name `Baz`."}

{"answer": "noyes", "explanation": "class_exists('Foo') looks for a global class and fails, while class_exists('Ns\\Foo') via __NAMESPACE__ finds the namespaced class."}

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

{"answer": 3, "explanation": "Since PHP 8.1, an inherited method that isn't overridden shares its static variables with the parent, so the counter goes 1, 2, 3."}

{"answer": 11, "explanation": "Calling send(10) on an unstarted generator first runs it to the first yield, then resumes it with 10 as the yield's result, so $x is 10 and the return value is 10 + 1 = 11."}

{"answer": "ok,2", "explanation": "The inner keys 0 and 1 yield 1 and 2, then outer's own `yield $r` uses its auto-key 0, overwriting the earlier value 1 in iterator_to_array, leaving [0 => 'ok', 1 => 2]."}

{"answer": "noyes", "explanation": "The first check returns false because the hash already uses cost 4, and the second returns true because the requested cost 5 differs from 4."}

{"answer": "strict-in", "explanation": "E_ALL is 32767 in PHP 8, which includes the E_STRICT bit (2048), so 32767 & 2048 is 2048, not 0, and the ternary picks 'strict-in'."}

```json ⏎ {"answer": "mapped", "explanation": "Symfony's Request builds its headers bag from HTTP_-prefixed server keys, so HTTP_X_TOKEN becomes the X-Token header, which is read case-insensitively."} ⏎ ```

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

{"answer": "same", "explanation": "The persisted entity is already in the identity map after flush, so both find() calls return the same managed instance, which is also $u."}

{"answer": 0, "explanation": "Removing an entity that was persisted but not yet flushed cancels its pending INSERT, so no row is written and the users table stays empty."}

{"answer": 1, "explanation": "count(x) counts only non-NULL values in column x, and the table holds one non-NULL value (1) and one NULL."}

```json ⏎ {"answer": "10,30,60", "explanation": "The window sum with ORDER BY id uses a running frame, giving 10, 30, 60 for ids 1, 2, 3, and string_agg joins them in id order."} ⏎ ```

{"answer": "M1M2", "explanation": "The bus runs middleware in array order: M1 echoes first, then calls next() which runs M2, so the output is M1 followed by M2."}

{"answer": 11, "explanation": "HandleMessageMiddleware invokes every handler registered for Ping, so $d1 adds 1 and $d2 adds 10, giving 11."}

{"answer": 1, "explanation": "The unique index makes the second INSERT of the value 1 conflict, and ON CONFLICT DO NOTHING skips it, so only one row remains."}

{"answer": 2, "explanation": "The unique constraint is deferred until commit, so both duplicate rows are visible to the SELECT inside the open transaction."}

{"answer": 6, "explanation": "The filter `test_sum` is a substring match, so it selects both `test_sum` and `test_sum_abs`, each with 3 data sets, while `test_other` is excluded."}

{"answer": "2, 1", "explanation": "The data provider yields two rows, so two tests run; the row [-1] fails the assertTrue($x > 0) check, while [1] passes."}

{"answer": "POST", "explanation": "Using curl's -d (--data) option with no explicit -X flag makes curl send the request as an HTTP POST."}

{"answer": "GET", "explanation": "The -G (--get) flag makes curl append the -d data to the URL as a query string and send a GET request."}

{"answer": "invalid_client", "explanation": "RFC 6749 Section 5.2 defines invalid_client for failed client authentication, which includes an unknown client_id."}

{"answer": "fragment", "explanation": "With the implicit grant (response_type=token), the authorization server returns the access_token in the URL fragment (after #) of the redirect_uri."}

{"answer": 6, "explanation": "The default filter returns 2 because false is treated as empty, and the filter binds before the multiplication, so 2 * 3 = 6."}

{"answer": "none", "explanation": "Twig gives `~` higher precedence than `+`, so this evaluates as ('a' ~ 1) + 2, which becomes 'a1' + 2; PHP 8 raises only a warning for the non-numeric string and yields 2, so no exception is thrown."}

{"answer": 0, "explanation": "The value `['']` is a non-empty array, so `NotBlank` (which fails only on false, null, '' or empty values) doesn't flag it, and no violations are returned."}

{"answer": "invalid", "explanation": "A form that has not been submitted makes isValid() return false rather than throw, so the ternary echoes 'invalid'."}

{"answer": "same", "explanation": "Services are shared by default in Symfony's ContainerBuilder, so both get('a') calls return the same instance and have the same object id."}

{"answer": "hi Bob!", "explanation": "compile() resolves the nested placeholders recursively: %greeting% expands to 'hi %name%', which expands to 'hi Bob', so the result is 'hi Bob!'."}

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

{"answer": "text-danger", "explanation": "Both classes use !important with equal specificity, so the one declared later in Bootstrap's generated CSS wins, and text-danger comes after text-primary in the theme color order."}

{"answer": 2, "explanation": "The Domain class depends on Application's PlaceOrder and Infrastructure's Db, and Domain may only depend on Domain, so each of these two references is a violation."}

{"answer": 3, "explanation": "The Domain class depends on three Application/Infrastructure classes (PlaceOrder, Db, and the fully qualified Logger), and Domain may only depend on Domain, so each reference is a violation."}

{"answer": "10,15", "explanation": "The add method returns a new Money instance with amount 15 without modifying $a, so $a->amount stays 10 and the output is '10,15'."}

{"answer": 1, "explanation": "After adding 'a', remove('a') sees count 1, throws DomainException before unsetting, which is caught, so the count stays 1."}

{"answer": "hi", "explanation": "Since PHP 8.4, a `new` expression with explicit parentheses can be followed directly by `->method()`, so this calls `hi()` on the new C instance and echoes 'hi'."}

{"answer": "yesno", "explanation": "The ghost starts uninitialized (yes), and reading $o->v runs the initializer, so it is no afterwards."}

{"answer": "no", "explanation": "AbstractGuardAuthenticator was deprecated in Symfony 5.3 and removed in 6.0, so class_exists() returns false on 8.1 and the ternary prints 'no'."}

{"answer": "noyes", "explanation": "AnnotationClassLoader was deprecated in 6.4 and removed in 7.0, so class_exists returns false, while AttributeClassLoader exists (abstract classes still count for class_exists)."}