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

{"answer": "no", "explanation": "Double-quoted strings interpolate variables and process escape sequences like \\n, while single-quoted strings do not (only \\' and \\\\ are escaped), so they are not processed identically."}

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

{"answer": "ab", "explanation": "echo accepts multiple comma-separated arguments and prints each one in sequence with no separator, so 'a' followed by 'b' outputs 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": "In PHP 8, the concatenation operator (.) was given lower precedence than + and -, so arithmetic is evaluated before concatenation."}

{"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 arithmetic + binds tighter than the concatenation operator ., so 2 + 3 is evaluated first, giving 'sum: ' . 5."}

{"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 == order doesn't matter."}

{"answer": "no", "explanation": "0 == false is a loose comparison that converts both operands to a common type and evaluates to true; strict comparison (===) would return false."}

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

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

{"answer": 42, "explanation": "PHP's (int) cast on a leading-numeric string takes the numeric prefix '42' and ignores the trailing non-numeric characters."}

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

{"answer": "no", "explanation": "In PHP, casting false to a string yields an empty string \"\", not \"0\"; it is true that integer 0 or 0.0 casts to \"0\"."}

{"answer": "yes", "explanation": "In PHP, 0.1 + 0.2 evaluates to 0.30000000000000004 due to binary floating-point representation, so 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() can pad on the right (STR_PAD_RIGHT, the default), the left (STR_PAD_LEFT), or both sides (STR_PAD_BOTH)."}

{"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 the accented character 'é' takes 2 bytes in UTF-8, so 'héllo' is 5 characters but 6 bytes."}

{"answer": "def", "explanation": "A negative start position in substr counts from the end of the string, so -3 begins at the third-from-last character and returns the rest: 'def'."}

{"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 interpolate variables like double-quoted strings, while nowdoc strings are literal like single-quoted strings and do not interpolate."}

{"answer": "no", "explanation": "PHP's sort() discards the original keys and reindexes the array numerically from 0; asort() or uasort() preserve key associations."}

{"answer": "yes", "explanation": "PHP converts decimal integer-like string keys such as '5' to integer keys, so '5' and 5 refer to the same element."}

{"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 truthy values, so falsy elements such as null, false, 0, 0.0, \"\", and empty arrays are removed."}

{"answer": "no", "explanation": "By default, array_slice() reindexes numeric keys starting from 0; it only preserves them when the preserve_keys argument is set to true."}

{"answer": "[20, 30]", "explanation": "array_slice starts at index 1 and takes 2 elements, giving the values 20 and 30 as a new array."}

{"answer": 2, "explanation": "The + operator on arrays performs a union, keeping the left array's 'a' key and adding 'b', giving ['a' => 1, 'b' => 2] with 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 added support for unpacking arrays with string keys using the spread operator, not just integer-keyed arrays."}

{"answer": "no", "explanation": "Since PHP 8.1, named arguments can be mixed with argument unpacking (e.g., `foo(...$positional, name: 1)`), and string-keyed arrays can be unpacked as named arguments."}

{"answer": "no", "explanation": "In PHP, a closure without a use clause cannot access variables from the enclosing scope; they must be imported with use (arrow functions are the exception, auto-capturing by value)."}

{"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's arrow functions (`fn`) take only a single expression after `=>` and do not support curly-brace bodies; multi-statement bodies require a regular `function` or `function() use (...) { }` closure."}

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

{"answer": "yes", "explanation": "A static closure is declared with the static keyword, which prevents it from automatically binding $this from the surrounding context, so it cannot use $this."}

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

{"answer": "yes", "explanation": "Without declare(strict_types=1), PHP coerces the numeric string \"5\" to the integer 5 for an int parameter under weak typing rules."}

{"answer": "yes", "explanation": "Constructor property promotion, introduced in PHP 8.0, lets constructor parameters with visibility modifiers automatically declare and assign class properties."}

{"answer": "final", "explanation": "Declaring a method with the final keyword prevents subclasses 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, line, and a suffix, so the part before the NUL is \"class@anonymous\"."}

{"answer": "yes", "explanation": "In PHP, private methods are not overridden, so a child class can declare a method with the same name and any visibility without triggering the usual compatibility rules."}

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

{"answer": "Error", "explanation": "Modifying an initialized readonly property throws an Error (not an Exception), with the message 'Cannot modify readonly property'."}

{"answer": "yes", "explanation": "PHP interfaces can declare constants, which implementing classes inherit and cannot override (prior to PHP 8.1, overriding was disallowed; since 8.1 they can be overridden only if not final)."}

{"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 method signatures, and any class implementing the interface must provide those methods."}

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

{"answer": "no", "explanation": "PHP interface methods cannot have a body or default implementation; they are only signatures, while traits are where default method implementations live."}

{"answer": "yes", "explanation": "Abstract methods can be declared public or protected, but not private, since a private method cannot be overridden by a child class."}

{"answer": 3, "explanation": "Foo::cases() returns an array of all enum case instances, and this enum declares three cases: A, B, and C."}

{"answer": "yes", "explanation": "Traits can declare constants since PHP 8.2, though they were not allowed in earlier versions."}

{"answer": "yes", "explanation": "In PHP 7 and later, Throwable is the base interface implemented by both the Exception and Error classes."}

{"answer": "no", "explanation": "TypeError extends Error, not Exception, so catch (Exception $e) does not catch it; Error and Exception are separate hierarchies that both implement Throwable."}

{"answer": "no", "explanation": "The @ operator only suppresses error messages (warnings, notices, and deprecations) by temporarily setting error_reporting; it does not catch or suppress exceptions, which must be handled with try/catch."}

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

{"answer": "no", "explanation": "In PHP, the finally block runs whether or not an exception was thrown or caught, including when no exception occurs at all."}

{"answer": "no", "explanation": "An exception thrown in a finally block replaces any exception or return value that was pending from the try block, so it does affect the outcome."}

Objects cast to bool are always true in PHP, so the result is true. The format asks for yes/no for true/false questions, but this is a result question, so I'll answer with "yes" to represent true. ⏎  ⏎ {"answer": "yes", "explanation": "Any object cast to bool is true in PHP, so casting a new Exception object yields true."}

{"answer": "yes", "explanation": "Shutdown functions run after script execution ends, including when exit() is called, so the statement is true."}

{"answer": "no", "explanation": "A use statement only creates an alias for a fully qualified 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": "In PHP, the keyword \"use function\" imports a function name into the current namespace, while \"use const\" imports constants."}

{"answer": "src/Controller/Api/UserController.php", "explanation": "PSR-4 maps the namespace prefix App\\ to src/, so the remaining namespace segments Controller\\Api become directories and the class name becomes the filename with .php appended."}

{"answer": "no", "explanation": "Including vendor/autoload.php does not itself register autoloaders; it is Composer's generated file that loads the autoload.php/classmap setup, and the actual registration via spl_autoload_register() is performed by Composer's ClassLoader class it loads, so the statement is only loosely true, but as phrased the file itself is the loader, making this a common misconception rather than a clear fact."}

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

{"answer": "no", "explanation": "An unqualified class name in `new` is resolved relative to the current namespace (or via imports), 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, namespace `use` imports must appear at the top level of a file or namespace block, not inside a function body; using them there is a syntax error (the only `use` inside a function is the closure `use` clause, which is different)."}

{"answer": "yes", "explanation": "In PHP, arrays are passed and assigned by value, so assigning an array creates a copy (implemented internally with copy-on-write), unlike objects, which are handled by reference to their handle."}

{"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, $GLOBALS array, or passed as parameters."}

{"answer": "no", "explanation": "In PHP, unset($GLOBALS['x']) inside a function removes the global variable itself, so it is gone everywhere, not just within that function."}

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

{"answer": "no", "explanation": "A by-value foreach iterates over a copy of the array, so changes made to the original array inside the loop are not seen in that pass."}

{"answer": "no", "explanation": "A static property belongs to the class itself and is shared by all instances, so a change made through one object is visible to all others."}

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

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

{"answer": "no", "explanation": "PHP generators cannot be rewound once they have advanced past the first yield; calling rewind() after that throws an Exception."}

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

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

{"answer": 3, "explanation": "`yield from [1, 2, 3]` yields three values with keys 0, 1, 2, and `iterator_to_array` preserves those keys, giving 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 is a built-in SPL class that implements the Iterator interface, letting you wrap an array and loop over it with foreach or manual iteration methods."}

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

{"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 needs to be supplied (the old salt option is deprecated and ignored since PHP 7.0)."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT currently maps to bcrypt (PASSWORD_BCRYPT), not md5, and it automatically generates a salt, so the statement is false."}

{"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 for output sanitization, and does nothing to prevent SQL injection; parameterized queries or prepared statements are needed instead."}

{"answer": "yes", "explanation": "Calling session_regenerate_id() after login issues a new session ID, preventing an attacker's pre-set session ID from being reused to hijack the authenticated session."}

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

{"answer": "yes", "explanation": "session_destroy() removes the session data stored on the server but does not expire the session cookie in the browser, which is why developers also call setcookie() with a past expiry to clear it."}

{"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 allow get and set logic declared directly within a 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 was added as part of the PHP 8.5 release, which warns when the return value of a marked function is discarded."}

```json ⏎ {"answer": "8.5", "explanation": "The pipe operator |> was accepted for PHP 8.5 after earlier proposals, and it was not part of PHP 8.4."} ⏎ ```

{"answer": "8.5", "explanation": "The clone-with syntax (clone($obj, [...])) was introduced in PHP 8.5 via the 'Clone With' RFC."}

{"answer": "8.5", "explanation": "array_first() and array_last() were added in PHP 8.5 via the accepted 'New array_find/array_first/array_last functions' RFC."}

{"answer": "none", "explanation": "Partial Function Application v2 was not adopted; PHP 8.1's first-class callable syntax (strlen(...)) covered the callable-creation need instead."}

{"answer": "8.5", "explanation": "I believe the clamp() function from the clamp_v2 RFC was added in PHP 8.5, but I'm not fully 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 as late as 2026-11-07."}

{"answer": "no", "explanation": "I have no record of a PHP RFC titled 'Bound-Erased Generic Types' being declined in 2026, so I can't confirm the claim."}

{"answer": "no", "explanation": "As far as my knowledge goes, ZTS (thread-safe builds) remains an opt-in compile option in PHP, and I know of no accepted RFC making it the default, though I can't verify events up to 2026-11-07."}

{"answer": "yes", "explanation": "PHP 8.5 does not include generics; the language still has no parameterized types, and related proposals have not been accepted."}

{"answer": "yes", "explanation": "PHP 8.5 was released in November 2025, so it would be the latest stable version on 2026-11-07, and the stated 8.6 GA date of 2026-11-19 falls after that."}

{"answer": "yes", "explanation": "PHP 6 was developed but never released as a stable version; the next major release after PHP 5.6 was PHP 7.0."}

{"answer": "yes", "explanation": "The #[\\Deprecated] attribute was added to PHP core in version 8.4 after its RFC was accepted, allowing userland functions and methods to be marked 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": "Keeping domain entities free of framework and ORM dependencies is a core principle of clean/hexagonal architecture, so they should rely only on PHP itself and possibly its standard library."}

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

{"answer": "Domain model", "explanation": "In onion architecture, the domain model (entities and domain logic) forms the innermost core, with layers of application services, infrastructure, and UI 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 exists."}

{"answer": "no", "explanation": "In Clean Architecture, use cases should not depend on framework or infrastructure details like HTTP requests or EntityManager; they should accept plain input data and depend on abstractions."}

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

{"answer": "yes", "explanation": "In clean architecture, the domain and use cases depend only on abstractions (ports/interfaces), so the database is an outer-layer detail that can be swapped without changing inner layers."}

{"answer": "no", "explanation": "In Domain-Driven Design, an aggregate is a cluster of domain objects treated as a single unit for data changes, which does not necessarily map one-to-one to a database table."}

{"answer": "yes", "explanation": "Value Objects are defined by immutability and equality based on their attribute values rather than object identity."}

{"answer": "Aggregate Root", "explanation": "The aggregate root is the single entry point to an aggregate, and all external changes to the aggregate's objects must go through it."}

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

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

{"answer": "Bounded context", "explanation": "In Domain-Driven Design, a bounded context is the boundary within which a domain model and its ubiquitous language stay consistent, while the same terms may mean different things outside it."}

{"answer": "no", "explanation": "Domain-Driven Design advocates rich domain models where behavior and invariants live within entities and value objects; anemic models with logic pushed into services are 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 (such as a Customer) can be modeled as different classes in different contexts."}

{"answer": "yes", "explanation": "The Symfony container instantiates a shared service only when it is first requested, not when the container is built."}

{"answer": "php bin/console debug:router", "explanation": "The debug:router command lists all registered routes in a Symfony application (in Symfony 4+ it is run via bin/console)."}

{"answer": "no", "explanation": "Symfony's autowiring and autoconfiguration let many services be registered automatically (e.g., via resource loading in services.yaml), so manual declaration of 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 source changes."}

{"answer": "yes", "explanation": "In dev mode (debug enabled), Symfony checks timestamps of tracked resources like config and service files and rebuilds the cached container only when they change."}

{"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's controller resolution calls the method from outside the class, so the controller method must be public; a private method is not callable and will fail."}

{"answer": "no", "explanation": "Subscribers are registered as ordinary listeners, and their execution order is determined by priority values, not by the subscriber interface itself."}

{"answer": "yes", "explanation": "Symfony 5.1 introduced the authenticator system, and Symfony 6.0 removed the deprecated Guard authenticators, leaving AuthenticatorInterface as the standard."}

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

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

{"answer": "yes", "explanation": "Symfony 7 removed support for annotation-based validation constraints, so constraints are declared with PHP attributes such as #[Assert\\NotBlank]."}

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

{"answer": "yes", "explanation": "Symfony form validation is applied on the server when the form is submitted and validated, regardless of any HTML5 client-side 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 does not store the plain-text password in the session; after authentication the user object is serialized into the session, and passwords are hashed and typically erased via eraseCredentials()."}

{"answer": "yes", "explanation": "Symfony stores bundle configuration in YAML, XML, or PHP files under config/packages, typically one file per bundle or topic."}

{"answer": "yes", "explanation": "This matches the Symfony Dotenv convention: .env is committed with defaults, while .env.local holds machine-specific overrides and secrets and is excluded from version control."}

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

{"answer": "no", "explanation": "After the container is compiled, its parameter bag is frozen, so calling setParameter() at runtime throws a LogicException; parameters must be changed in configuration instead."}

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

{"answer": "no", "explanation": "Bundles do not require a config file in config/packages; many work with sensible defaults, and configuration is optional unless the bundle explicitly needs it."}

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

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

{"answer": "no", "explanation": "Symfony Messenger allows a single message to be routed to multiple handlers, and each matching handler will be invoked."}

{"answer": "no", "explanation": "The sync transport in Symfony Messenger handles the message immediately in the same process instead of queuing it 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, the retry_strategy (max_retries, delay, multiplier, max_delay) is set on each transport under framework.messenger.transports, so retries are configured per transport."}

{"answer": "yes", "explanation": "Symfony Messenger's default transport serializer encodes messages as JSON using the Symfony Serializer component."}

{"answer": "yes", "explanation": "The Symfony Scheduler component generates recurring messages from a schedule 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 a doctrine:// DSN."}

{"answer": "yes", "explanation": "Symfony Messenger lets you define custom middleware in the bus configuration, and it can be ordered before or after the built-in middleware."}

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

{"answer": "8.4", "explanation": "Symfony 8.0 requires PHP 8.4 or higher, as Symfony 7.4 requires PHP 8.2 and Symfony 8 raises the baseline."}

{"answer": "no", "explanation": "Symfony 7.0 dropped support for docblock annotations in favor of PHP 8 attributes, so routes and validation constraints must now use attributes."}

{"answer": "yes", "explanation": "Symfony's AssetMapper component serves and versions CSS/JS assets directly without Node.js or Webpack, using the importmap.php file to map JavaScript module imports to asset paths."}

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

{"answer": "no", "explanation": "Symfony's upgrade policy is that features deprecated in one minor version are removed in the next major version, so deprecated code stops working when you move to a new major release."}

{"answer": "yes", "explanation": "Symfony publishes an UPGRADE-X.0.md file for each major release, documenting breaking changes and the steps needed 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 Symfony 8.0 would come in May 2026, 8.1 in November 2026, and 8.2 not until May 2027."}

{"answer": "no", "explanation": "Symfony minor releases follow a May/November cycle, so Symfony 8.0 is due in May 2026, 8.1 in November 2026, and 8.2 in May 2027, not November 2026."}

{"answer": "8.2", "explanation": "Symfony minor releases follow a May/November cadence, so after 8.1 (May 2026) the next minor is 8.2, due around November 2026."}

{"answer": "no", "explanation": "Symfony 8.2 would be a minor release, and Symfony keeps backward compatibility within a major version, so it would not require rewriting applications for new APIs."}

{"answer": "no", "explanation": "PHP minor releases aim for backward compatibility, but 8.2 added deprecations (such as dynamic property creation) that can require code changes, especially if deprecation notices are treated as errors."}

{"answer": 4, "explanation": "Symfony majors ship with minor releases every six months, and by analogy with 7.x (7.0 to 7.4 LTS), the 8.x branch should end at 8.4, the LTS release before 9.0."}

{"answer": "no", "explanation": "Symfony's PHP requirement is normally set per major version (Symfony 8.0 requires PHP 8.4), so a Symfony 8.2 requirement of PHP 8.5 is unlikely and not something I can confirm."}

{"answer": "yes", "explanation": "Symfony's backward compatibility policy says a feature deprecated in a minor release is only removed in the next major version, so deprecations added in 8.x can't be removed before 9.0."}

{"answer": "no", "explanation": "Twig expressions inside {{ }} use Twig's own syntax and only expose functions, filters, and tests that are registered, 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": "In Twig, the `e` filter is an alias of `escape`, which escapes strings for safe output, defaulting to the HTML context."}

{"answer": "format_number", "explanation": "Twig's intl-extra provides the format_number filter, which formats a number according to the current or specified locale."}

{"answer": "yes", "explanation": "In Twig, the raw filter (e.g., {{ value|raw }}) outputs the value without applying auto-escaping."}

{"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 lets you declare variables inside a template with the {% set %} tag, so values don't have to come only from the controller."}

{"answer": "dump", "explanation": "Twig's dump() function outputs debugging 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 ready-made 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 per row, not 16, and since Bootstrap 4 it is built on flexbox rather than floats."}

{"answer": "yes", "explanation": "Bootstrap 5 uses sm, md, lg, xl, and xxl as infixes in responsive class names, with xs having no infix."}

{"answer": "no", "explanation": "The number is an index into the $spacers map, not a direct multiplier: .mt-3 is $spacer (1rem) and .px-2 is 0.5 × $spacer, so .mt-3 is not 3 × $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 plain vanilla JavaScript."}

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

{"answer": "no", "explanation": "Doctrine ORM does not create tables at runtime; schema changes are made explicitly via commands such as doctrine:schema:update or migrations."}

{"answer": "persist", "explanation": "EntityManager::persist() marks an entity as managed so it will be inserted on flush(), without executing SQL immediately."}

{"answer": "no", "explanation": "merge() doesn't make the passed object managed; it returns a managed copy of it, and Doctrine ORM 3 removed merge() entirely."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) queries reference 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 you explicitly call EntityManager::flush(), and DoctrineBundle does not do this at the end of each request."}

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

{"answer": "no", "explanation": "In Doctrine ORM, 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 modify new row versions."}

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

{"answer": "no", "explanation": "SERIAL creates a sequence with a nextval() default that can be overridden by explicit inserts, while GENERATED AS IDENTITY is the SQL-standard form with stricter insert rules and different sequence dependency handling."}

{"answer": "no", "explanation": "In PostgreSQL, NULL values are considered distinct from one another, so a UNIQUE constraint allows multiple rows with NULL by default (NULLS NOT DISTINCT is needed to restrict this)."}

{"answer": "string_agg", "explanation": "PostgreSQL's string_agg(expression, delimiter) concatenates non-null input values into a 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 rewrites shrink the file."}

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

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

{"answer": "yes", "explanation": "PostgreSQL runs each standalone SQL statement in an implicit transaction that is committed 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 filter on an indexed column can locate the matching rows via the index instead of scanning the whole table, so they benefit as well."}

{"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 executing it."}

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

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

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE with Serializable Snapshot Isolation, which tracks read and write dependencies using non-blocking predicate locks and aborts transactions on conflicts, 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 9110 defines DELETE as idempotent, meaning repeated identical requests have the same intended effect on the server as a single request, though the response status may differ (for example, 404 on a second call)."}

{"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 indicates the user has sent too many requests in a given time, typically exceeding a rate limit."}

{"answer": "no", "explanation": "It is reversed: 4xx status 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 required to be idempotent under RFC 7231."}

{"answer": "no", "explanation": "A plain == comparison can leak timing information, enabling timing attacks; use hash_equals() or password_verify() instead."}

{"answer": "yes", "explanation": "A session-bound CSRF token issued by the server and validated on state-changing requests such as POST is the standard synchronizer token 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 permission to access resources and don't inherently identify the user (OpenID Connect adds the identity layer via ID tokens)."}

{"answer": "no", "explanation": "XSS is prevented by context-aware output encoding/escaping when data is rendered, not solely by validating input before storage, since data can reach output through other paths and the correct encoding depends on the HTML, attribute, or JavaScript context."}

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

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

{"answer": "no", "explanation": "Salts are stored alongside the hash (PHP's password_hash embeds it in the output), and their purpose is to defeat precomputed attacks, not to stay secret; the hash can be verified using the stored salt."}

{"answer": "no", "explanation": "PHPUnit only runs test methods in classes that extend PHPUnit\\Framework\\TestCase, which provides the assertions and test lifecycle."}

{"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 any number of argument sets, and the test runs once for each set, not just one."}

{"answer": "expectException", "explanation": "PHPUnit's TestCase::expectException($exception) declares that the test must throw an exception of the given class."}

{"answer": "no", "explanation": "It is reversed: a stub only returns canned data without verifying calls, while a mock records and verifies which methods were called on it."}

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

{"answer": "no", "explanation": "PHPUnit supports test dependencies via the @depends annotation (or #[Depends] attribute), so one test can depend on another's result."}

{"answer": "--order-by=random", "explanation": "PHPUnit's --order-by option with the random value runs tests in random order (also available via --random-order and --random-order-seed)."}

intdiv(7,2) = 3. intdiv(-7,2) truncates toward zero = -3. Concatenated: "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 the concatenation gives \"3-3\"."}

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

{"answer": "true", "explanation": "Both '1e1' and '10' are numeric strings, so == compares them as numbers (10 == 10), which is true."}

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

{"answer": "2c", "explanation": "With an array argument, strtr replaces the longest matching key first, so 'ab' becomes '2' and the remaining 'c' is unchanged."}

{"answer": "[hello]", "explanation": "When a negative start is larger in magnitude than the string length, substr clamps the start to 0, so the whole string 'hello' is returned and wrapped in brackets."}

{"answer": "k,n,m", "explanation": "The + operator merges arrays keeping the left array's keys first, so the union has keys k, n, then m from $b (k is not overwritten)."}

{"answer": "yxz", "explanation": "Sorting by the third element gives [2,'y',1], [1,'x',2], [3,'z',2] (stable in PHP 8), so column 1 is 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()` 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": "The set hook runs with $value = 5 and writes $this->x = 10 directly, which does not re-trigger the hook, so the backing value is 10 and reading it returns 10."}

{"answer": "BA", "explanation": "`TB::f insteadof TA` makes `f()` come from TB (returns 'B'), and `TA::f as g` aliases TA's method to `g()` (returns 'A'), so the output is 'BA'."}

{"answer": 0, "explanation": "A trait's static properties are copied into each class that uses it, so CX and CY each have their own $n, and setting CX::$n to 1 leaves CY::$n at its default of 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 pending RuntimeException, so the outer catch receives the LogicException and echoes its message."}

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

{"answer": "noyes", "explanation": "'Foo' isn't defined in the global namespace, so the first check is 'no', while 'Ns\\Foo' (built from __NAMESPACE__) does exist, so the second is 'yes'."}

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

{"answer": 3, "explanation": "Since PHP 8.1, an inherited method that is not overridden shares its static variables with the parent, so the calls increment a single counter: 1, 2, then 3."}

{"answer": 11, "explanation": "send() first advances the unstarted generator to the first yield, then sends 10 as that yield's result, so $x = 10 and the return value is 11."}

{"answer": "ok,2", "explanation": "yield from keeps the inner keys 0 and 1, then outer's own auto-key starts at 0, so 'ok' overwrites the value for key 0 and the array becomes [0=>'ok', 1=>2]."}

{"answer": "noyes", "explanation": "The first check compares the hash's cost (4) to the requested cost (4), so no rehash is needed; the second check requests cost 5, so a rehash is needed."}

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

{"answer": "mapped", "explanation": "Symfony's Request builds its headers from HTTP_-prefixed server variables, so HTTP_X_TOKEN becomes the X-Token header, and HeaderBag lookups are case-insensitive, returning 'abc'."}

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

{"answer": "same", "explanation": "Doctrine's identity map returns the same managed User instance for both find() calls, so the spl_object_id values match."}

{"answer": 0, "explanation": "Removing an entity that was persisted but not yet flushed cancels its scheduled insert, so flush writes nothing and the table stays empty."}

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

{"answer": "10,30,60", "explanation": "The default window frame gives running sums of 10, 30, and 60 for ids 1, 2, and 3, which string_agg joins in id order."}

{"answer": "M1M2", "explanation": "Each middleware echoes its tag before calling the next one, and the bus returns the envelope once the middleware chain is exhausted, so M1 then M2 are printed."}

```json ⏎ {"answer": 11, "explanation": "HandleMessageMiddleware invokes both distinct handler descriptors for Ping in turn, so $n becomes 1 + 10."} ⏎ ```

{"answer": 1, "explanation": "The unique index on a makes the second INSERT of 1 hit a conflict, which ON CONFLICT DO NOTHING silently skips, so only one row remains."}

{"answer": 2, "explanation": "The UNIQUE constraint is deferred until commit, so both duplicate inserts succeed within the transaction and the count sees both rows."}

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

```json ⏎ {"answer": "2, 1", "explanation": "The data provider yields two cases: [1] passes since 1 > 0, and [-1] fails since -1 is not > 0."} ⏎ ```

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

{"answer": "GET", "explanation": "The -G (--get) flag makes curl send the -d data as a query string appended to the URL, using the GET method instead of POST."}

{"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 URI fragment (after the #) of the redirect_uri."}

{"answer": 6, "explanation": "The default filter returns 2 because false counts as empty, and the filter binds tighter than *, so 2 * 3 = 6."}

{"answer": "2", "explanation": "Twig's `~` binds tighter than `+`, so it computes ('a' ~ 1) + 2 = \"a1\" + 2, which PHP 8 evaluates as 2 with a warning rather than throwing an exception."}

{"answer": 0, "explanation": "The value passed is the non-empty array [''], which is not null, false, or a blank string, so NotBlank raises no violation and the violation list is empty."}

{"answer": "invalid", "explanation": "Symfony's Form::isValid() returns false without throwing when the form has not been submitted, so the ternary echoes 'invalid'."}

{"answer": "same", "explanation": "Services registered with the default shared setting return the same instance on every get() call, so both object IDs match."}

{"answer": "hi Bob!", "explanation": "Symfony's ParameterBag resolves %name% inside greeting to 'hi Bob', then %greeting% inside message expands to 'hi Bob' with '!' appended."}

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

```json ⏎ {"answer": "text-danger", "explanation": "Both classes set color with !important and equal specificity, so the one defined later in Bootstrap's stylesheet wins, and text-danger comes after text-primary."} ⏎ ```

{"answer": 2, "explanation": "The Domain class depends on both Application (PlaceOrder) and Infrastructure (Db), and Domain may only depend on Domain, so each of those two type dependencies is a separate violation."}

{"answer": 3, "explanation": "The Domain class depends on PlaceOrder (Application) and on Db and Logger (Infrastructure), which Domain may not use, giving one violation per dependency."}

{"answer": "10,15", "explanation": "The add method returns a new Money object without modifying $a, so $a->amount stays 10 and $c->amount is 15."}

{"answer": 1, "explanation": "The single item is still present because remove() throws before the unset when the count is 1, so count() returns 1."}

{"answer": "hi", "explanation": "Since PHP 8.4, a method can be called directly on a `new` expression with parentheses, so `new C()->hi()` returns 'hi', which echo prints."}

{"answer": "yesno", "explanation": "The ghost object starts uninitialized, so the first check prints 'yes'; reading $o->v runs the initializer, which makes the second check print 'no'."}

{"answer": "no", "explanation": "The Guard authenticator classes were deprecated in Symfony 5.3 and removed in 6.0, so class_exists() returns false on 8.1."}

{"answer": "noyes", "explanation": "AnnotationClassLoader was deprecated in 6.4 and removed in 7.0, so class_exists returns false; AttributeClassLoader exists in 6.4 and later, so it returns true."}