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

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

{"answer": "yes", "explanation": "The ?? operator is effectively isset() plus a fallback, so it emits no notice or warning for undefined variables or array keys."}

{"answer": "ab", "explanation": "PHP's echo accepts multiple comma-separated arguments and prints them in sequence with no separator, so 'a' followed by 'b' gives 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 returns its left operand when it is truthy; when the left operand is falsy, it returns the right operand instead."}

{"answer": "yes", "explanation": "PHP 8 changed the precedence so that arithmetic + and - bind more tightly than the concatenation operator ., which now sits below them."}

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

{"answer": "sum: 5", "explanation": "In PHP 8, the arithmetic `+` binds tighter than the concatenation operator `.`, so `2 + 3` is computed 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; == ignores order, but === does not."}

{"answer": "no", "explanation": "0 == false evaluates to true because == is a loose comparison that converts both operands to a common type, while 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, so \"abc\" == 0 is false."}

{"answer": "yes", "explanation": "In PHP, null == 0, null == "", and null == false all evaluate to true under loose comparison, though 0 == "" is false in PHP 8, so these values aren't all equal to each other."}

{"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 numeric string '5' is converted to an integer during the addition, so '5' + 5 yields the integer 10."}

{"answer": "no", "explanation": "In PHP, casting false to a string gives an empty string \"\", not \"0\"; 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 bytes, not characters, so multibyte UTF-8 characters get corrupted when reversed."}

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

"héllo" has 5 characters, but é is 2 bytes in UTF-8, so total bytes = 6. ⏎  ⏎ {"answer": 6, "explanation": "PHP's strlen counts bytes, and the accented é occupies two bytes in UTF-8, so 'héllo' is 6 bytes."}

{"answer": "def", "explanation": "A negative start position in substr counts from the end of the string, so -3 begins at the third-to-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 string passed to it."}

{"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() discards the original keys and reindexes the array with sequential numeric keys; asort() preserves key-to-value associations."}

{"answer": "yes", "explanation": "PHP converts numeric string keys that are canonical decimal integers, such as '5', into integer keys, so '5' is stored as 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 are truthy, 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 values 20 and 30 as a new array (the result is an array, so it is given here in array notation)."}

{"answer": 2, "explanation": "The + operator merges arrays, keeping the left value for 'a' (1) and adding the missing key 'b', giving two elements."}

{"answer": "yes", "explanation": "PHP 8.1 added support for unpacking arrays with string keys using the spread operator in array literals, so [...$a, ...$b] now works with string-keyed arrays."}

{"answer": "no", "explanation": "Since PHP 8.1, you can combine them, as in `f(...$positional, name: $value)`, provided the spread comes before the named arguments; string keys in an unpacked array are also treated as named arguments."}

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

{"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) take only a single expression after =>, and curly braces with multiple statements are not allowed; a block body requires a regular function."}

{"answer": "no", "explanation": "PHP arrow functions capture outer variables by value at the time the arrow function is created, not by reference or lazily at use 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 definition time when $x is 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."}

{"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 with the final keyword prevents child classes from overriding it."}

{"answer": "yes", "explanation": "In PHP, declaring a method as final prevents any subclass from overriding it, and attempting to do so causes a fatal error."}

{"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, the file path, and a line/offset suffix, so the part before the NUL is 'class@anonymous'."}

{"answer": "yes", "explanation": "In PHP, private methods are not visible to child classes, so a child can declare a method with the same name using 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 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 child interfaces/classes may override 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 methods, as long as the implementing classes define them with compatible signatures."}

{"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 cannot have a body or default implementation; they are only declarations, and code reuse requires traits or classes."}

{"answer": "yes", "explanation": "Abstract methods may be declared public or protected (but not private, since private methods cannot be overridden by child classes)."}

{"answer": 3, "explanation": "Foo::cases() returns an array of all declared enum cases, 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 implements the Throwable interface and extends Error, not Exception, so catch (Exception $e) does not catch it."}

{"answer": "no", "explanation": "The @ operator only suppresses PHP error messages (warnings, notices, deprecations) by temporarily changing error_reporting; it does not catch or suppress thrown exceptions."}

{"answer": "DivisionByZeroError", "explanation": "intdiv() throws a DivisionByZeroError when the divisor is zero, as does the / and % operators on integers."}

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

Casting any object to bool in PHP yields true, regardless of its properties. So the result is true, which in the required format is "yes". ⏎  ⏎ {"answer": "yes", "explanation": "Any object cast to bool is always true in PHP, so (bool) new Exception('x') evaluates to true."}

{"answer": "yes", "explanation": "Shutdown functions run after script execution ends, including when exit() is called, and also after a fatal error."}

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

{"answer": "function", "explanation": "In PHP, the 'use function' statement 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 loads Composer's autoload setup, which in turn calls spl_autoload_register() to register the autoloader, so the statement is only loosely true, but as phrased it's false because the file is Composer's bootstrap that registers the loader rather than the include directly being the registration mechanism."}

{"answer": "yes", "explanation": "__NAMESPACE__ is a PHP magic constant that holds 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 `use` imports), not from the global root; only a leading `\` makes it fully qualified."}

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

{"answer": "no", "explanation": "Namespace import `use` statements are only allowed at file or namespace level, not inside function bodies (the `use` keyword inside a closure is a different construct)."}

{"answer": "yes", "explanation": "In PHP, arrays are assigned by value, so `$b = $a` creates a copy (implemented with copy-on-write), and changes to one don't affect the other."}

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

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

{"answer": "no", "explanation": "Unsetting $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 is passed by reference (&$x), so incrementing $x inside the function changes the caller's $n from 5 to 6."}

{"answer": "no", "explanation": "A foreach by value iterates over a copy of the array, so changes made to the original 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 a change made through one object is visible to all others."}

{"answer": "no", "explanation": "PHP casts boolean array keys 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": "Generators cannot be rewound once consumed; calling rewind() after the generator has advanced past its first yield throws an Exception, so it cannot be traversed again."}

{"answer": "yes", "explanation": "PHP's yield from expression delegates iteration to another generator, Traversable object, or array, passing through its yielded values."}

{"answer": "Generator", "explanation": "Calling a function containing yield returns a Generator object, so get_class returns the class name \"Generator\"."}

{"answer": 3, "explanation": "`yield from [1, 2, 3]` yields three key-value pairs with unique keys 0, 1, 2, so `iterator_to_array` (preserving keys by default) produces an array of three elements."}

{"answer": "no", "explanation": "SplStack is a LIFO (last in, first out) structure; the FIFO queue behavior belongs to SplQueue."}

{"answer": "yes", "explanation": "ArrayIterator implements the SeekableIterator interface and lets you traverse an array (or object) using the standard Iterator methods like current(), key(), next(), rewind(), and valid()."}

{"answer": "no", "explanation": "ArrayObject implements IteratorAggregate, 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 a salt does not need to be supplied separately."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT currently refers to bcrypt (and may change to stronger algorithms in future), not md5, which is not suitable for password hashing."}

{"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; use prepared statements or parameterized queries instead."}

{"answer": "yes", "explanation": "Calling session_regenerate_id() on login issues a new session ID, so an attacker's pre-set session ID is no longer valid for the authenticated user."}

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

{"answer": "yes", "explanation": "session_destroy() removes the session data stored on the server, but the session cookie remains in the browser unless it is explicitly expired, for example with setcookie()."}

{"answer": "no", "explanation": "Without calling session_start() (or having 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 functions alongside array_find_key(), array_any(), and array_all()."}

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

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

{"answer": "8.5", "explanation": "The #[\\NoDiscard] attribute was added in PHP 8.5, warning when the return value of a marked function is discarded."}

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

{"answer": "8.5", "explanation": "The clone-with syntax, which lets clone accept an array of property overrides, was added in PHP 8.5."}

{"answer": "8.5", "explanation": "The array_first() and array_last() functions were added in PHP 8.5, following an accepted RFC."}

{"answer": 8.6, "explanation": "I believe the Partial Function Application v2 RFC was accepted for PHP 8.6, though I'm not fully certain of this."}

{"answer": "8.5", "explanation": "The clamp_v2 RFC for a clamp() function was implemented in PHP 8.5, released in November 2025; I'm not fully certain of this from memory."}

{"answer": "no", "explanation": "I have no record of a 'Context Managers v2' RFC being adopted into PHP, and I can't verify the status as of the stated date."}

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

{"answer": "no", "explanation": "As far as I know, PHP's Zend Thread Safety (ZTS) build remains opt-in and no RFC making it the default has been accepted, though my knowledge of events up to 2026 may be incomplete."}

{"answer": "yes", "explanation": "PHP 8.5 does not add generics; parameterized types remain unsupported in the language."}

{"answer": "yes", "explanation": "PHP 8.5 was released in November 2025, and the next version is not scheduled until late 2026, so it should not be out as of 2026-11-07."}

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

{"answer": "yes", "explanation": "The #[\\Deprecated] attribute was added to PHP core in version 8.4 through an RFC that was accepted and implemented."}

{"answer": "yes", "explanation": "In clean and onion architectures, source code dependencies point inward toward the domain at the center, 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) 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 other layers wrapping around it."}

{"answer": "yes", "explanation": "Tools like deptrac check PHP class dependencies against declared layer rules and fail the build when a forbidden cross-layer dependency occurs."}

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

{"answer": "Repository", "explanation": "A repository provides a collection-like interface for 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 implemented by adapters 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, and it is not the same as a database table, though it may be persisted across one or more tables."}

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

{"answer": "Aggregate Root", "explanation": "The aggregate root is the single entity through which all external access and state changes to the aggregate must pass, enforcing its invariants."}

{"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 the shared vocabulary built from the domain model and used consistently by developers and domain experts."}

```json ⏎ {"answer": "domain of discourse", "explanation": "The domain of discourse is the set of objects over which a language's terms range, and outside it the same words can be interpreted as referring to different models."} ⏎ ```

{"answer": "no", "explanation": "DDD 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 (e.g., a Customer) can have different representations and classes in different contexts."}

{"answer": "yes", "explanation": "By default, Symfony's container instantiates a service only when it is first requested, though the separate `lazy` option (proxy-based) is not enabled by default."}

{"answer": "php bin/console debug:router", "explanation": "The debug:router command lists all registered routes in a Symfony application (aliased as debug:route in some versions)."}

{"answer": "no", "explanation": "Symfony's autowiring and autoconfiguration let services be registered automatically 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 source template changes."}

{"answer": "yes", "explanation": "In dev, Symfony checks the container's tracked resource files for changes on each request and rebuilds the container only when one of them is modified."}

{"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 can only invoke public controller methods, so a private method cannot be called by the router."}

{"answer": "no", "explanation": "Event subscribers are not prioritized by their interface; their execution order is determined by the priority values each event is registered with, so they can run before or after other listeners."}

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

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute (Symfony\\Component\\Security\\Http\\Attribute\\IsGranted) checks a role or permission on a controller method and throws an access denied (403) exception if the check 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.0 removed support for Doctrine-style annotations across its components, so validation constraints are now declared only with PHP attributes like #[Assert\\NotBlank]."}

{"answer": "yes", "explanation": "Symfony forms enable CSRF protection 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, regardless of any client-side HTML5 validation that may have passed."}

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

{"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 stored in plain text."}

{"answer": "yes", "explanation": "Symfony keeps bundle configuration in the config/packages directory, typically with one YAML (or PHP/XML) file per bundle or configuration topic."}

{"answer": "yes", "explanation": "This matches the common Symfony-style convention: a committed .env holds non-secret dev defaults, while .env.local (listed in .gitignore) holds machine-specific or real secrets."}

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

{"answer": "no", "explanation": "After container compilation the parameter bag is frozen, so calling setParameter() at runtime throws a LogicException (\"Impossible to call set() on a frozen ParameterBag\")."}

{"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 work with default configuration; a config file in config/packages is optional and only needed to override defaults or set required options."}

{"answer": "yes", "explanation": "Symfony's container supports the %env(VAR)% syntax in YAML config 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 class to have multiple handlers, and each one is invoked when the message is dispatched."}

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

{"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, etc.) is set under each transport's configuration, so retries are configured per transport."}

{"answer": "yes", "explanation": "Symfony Messenger's default transport serializer (messenger.transport.symfony_serializer) encodes messages in JSON format."}

{"answer": "yes", "explanation": "Symfony Scheduler generates recurring messages from a schedule and hands them to the Messenger component for dispatch via its scheduler transport and worker."}

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

{"answer": "yes", "explanation": "Symfony Messenger buses accept custom middleware in their configuration, and it can be ordered before or after the default middleware."}

{"answer": "yes", "explanation": "Symfony's official release policy is a new major version every two years and minor versions every six months, with minor releases published in May and November."}

{"answer": "8.4", "explanation": "Symfony 8.0 requires PHP 8.4 or higher, as Symfony 7.4 was the last line supporting PHP 8.2 and 8.3."}

{"answer": "no", "explanation": "Symfony dropped docblock annotation support for routing and validation in favor of PHP attributes, starting with 6.0, so 7.0 does not support them."}

{"answer": "yes", "explanation": "Symfony's AssetMapper component serves and versions CSS and JS without Node.js or webpack, and maps JavaScript dependencies through the importmap.php file."}

{"answer": "no", "explanation": "Symfony 6.4 is a long-term support (LTS) release, receiving bug fixes for 3 years and security fixes for 4 years, so it is not a regular release."}

{"answer": "no", "explanation": "Symfony deprecates features in a minor release and removes them in the next major version, so deprecated code generally stops working after a major upgrade."}

{"answer": "yes", "explanation": "Symfony publishes UPGRADE-X.0.md files in its repository for each major version, documenting breaking changes and migration steps."}

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

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

{"answer": "no", "explanation": "Under the six-month cycle, Symfony 8.0 is due May 2026 and 8.1 in November 2026, so 8.2 would follow in May 2027, not November 2026."}

{"answer": "8.2", "explanation": "Symfony ships a new minor version every six months, so the minor release after 8.1 would be 8.2; the question's date premise looks inconsistent with the usual schedule, where 8.0 falls in November 2026."}

{"answer": "no", "explanation": "Symfony 8.2 would be a minor release, and Symfony's backward compatibility policy means minor versions don't require rewriting applications for new APIs."}

{"answer": "no", "explanation": "PHP 8.2 deprecated several features, such as dynamic property creation and utf8_encode/utf8_decode, so upgrading from 8.1 can require code changes to avoid deprecation notices and some breakage."}

{"answer": 4, "explanation": "Symfony majors follow a pattern where the fourth minor (x.4) is the LTS and last release before the next major, as with 7.4 before 8.0, so 8.4 should be the last 8.x minor."}

{"answer": "no", "explanation": "Symfony generally raises its minimum PHP version only with major releases, and Symfony 8.0 requires PHP 8.4, so 8.2 is unlikely to require PHP 8.5; I'm not certain of the 8.2 requirement."}

{"answer": "yes", "explanation": "Symfony's backward compatibility policy keeps features deprecated in a minor version until the next major version, so 8.x deprecations are not removed before 9.0."}

{"answer": "no", "explanation": "Twig expressions can only use Twig's own operators, filters, functions, and tests, not arbitrary PHP code, and calling PHP functions requires registering them as Twig functions or filters."}

{"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": "Twig's `e` filter is an alias of `escape`, which defaults to HTML escaping, so it makes a string safe for HTML output."}

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

{"answer": "yes", "explanation": "In Twig, the raw filter 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 supports declaring variables within a template using the `{% set %}` tag, so values are not limited to those passed 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 sets a responsive fixed max-width that changes at each breakpoint."}

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

{"answer": "yes", "explanation": "Bootstrap 5 uses the infixes sm, md, lg, xl, and xxl for its five named breakpoints, while xs has no infix."}

{"answer": "no", "explanation": "The number is only a key into the spacing map. For example, .mt-3 is $spacer ($spacer * 1), not 3 times $spacer, and .mt-5 is $spacer * 3."}

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the data-bs-toggle attribute initializes interactive components such as dropdowns, modals, and collapses without custom JavaScript."}

{"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 a data-bs-theme=\"dark\" attribute on the root 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(), 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) 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 EntityManager::flush() is explicitly called by the application code."}

{"answer": "yes", "explanation": "Once an entity is managed (persisted or loaded by the EntityManager), the Unit of Work tracks its changes, so flush() writes them without calling persist() again."}

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

{"answer": "EXPLAIN", "explanation": "EXPLAIN displays the query's execution plan without running the query, whereas EXPLAIN ANALYZE would actually execute it."}

{"answer": "no", "explanation": "SERIAL creates a sequence with a nextval() default, while GENERATED ... AS IDENTITY is the SQL-standard mechanism with stricter rules, such as blocking explicit inserts unless OVERRIDING SYSTEM VALUE is used."}

{"answer": "no", "explanation": "PostgreSQL treats NULLs as distinct in UNIQUE constraints by default, so multiple rows with NULL in the column are allowed (unless NULLS NOT DISTINCT is specified in PostgreSQL 15+)."}

{"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) shrinks the file."}

{"answer": "PARTITION BY", "explanation": "The PARTITION BY clause divides the result set into groups over which the window function is computed independently."}

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

{"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 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 the surrounding transaction remains active."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports real run-time statistics, whereas plain EXPLAIN shows the plan without executing 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 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: repeated identical requests leave the server in the same state, even if the response status (such as 200 then 404) differs."}

{"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 client has sent too many requests in a given time period, 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": "Plain == comparison of hashes can leak timing information, so hash_equals() should be used; also password checks should use password_verify() with a proper password hash."}

{"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 specifies 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 do not 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 data is rendered, since input validation alone cannot stop all XSS and data may be safe in one context but dangerous in another."}

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

{"answer": "yes", "explanation": "Refresh tokens have a longer lifespan 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 and are not secret; they exist to defeat precomputed rainbow-table attacks, and verification uses the stored salt."}

{"answer": "no", "explanation": "PHPUnit only runs test classes that extend PHPUnit\\Framework\\TestCase (or a compatible base), so extending it is required."}

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

{"answer": "no", "explanation": "A PHPUnit data provider makes the test run once for each argument set it returns, so it can run many times, not just once."}

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

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

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

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

{"answer": "--order-by=random", "explanation": "PHPUnit's --order-by option with the random value runs tests in random order (the --random-order flag is also available in some 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 ternary outputs 'true'."}

{"answer": "other", "explanation": "In PHP 8, the non-numeric string 'a' compared loosely with 0 is compared as strings ('a' vs '0'), so it is not equal and the default branch runs (PHP 7 would have printed 'zero')."}

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

{"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 merges arrays, keeping $a's keys first (k, n), then adding only new keys from $b (m), since k already exists."}

{"answer": "yxz", "explanation": "usort sorts by the third element ascending, giving [2,'y',1], then [1,'x',2] and [3,'z',2] in their original order since PHP 8's sort is stable, so the column-1 values are y, x, z."}

Spread with string keys maps to named parameters: a=5, b=1, so 5-1=4. ⏎  ⏎ {"answer": 4, "explanation": "Argument unpacking with string keys binds by parameter name, so a=5 and b=1, giving 5 - 1 = 4."}

{"answer": 3, "explanation": "The first-class callable `$p->g(...)` holds a reference to the P object, so setting `$p = null` doesn't 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 to the backing property without re-triggering the hook, and with no get hook the read returns 10."}

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

{"answer": 0, "explanation": "Static properties declared in a trait are copied into each class that uses it, so CX::$n and CY::$n are independent and CY::$n remains at its initial value of 0."}

{"answer": 2, "explanation": "A return inside the finally block overrides the pending 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 with message 'second'."}

{"answer": "App\\Foo|Baz", "explanation": "The `use App\\Foo as Baz` alias makes `Baz::class` resolve to `App\\Foo`, while `\\Baz::class` is fully qualified and resolves to `Baz`."}

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

{"answer": "1,2,99", "explanation": "After foreach by reference, $v remains a reference to the last element $a[2], so $v = 99 overwrites that element."}

{"answer": 3, "explanation": "Since PHP 8.1, an inherited method that isn't overridden shares its static variables with the parent, so A::inc() and B's inherited inc() use one counter: 1, then 2, then 3."}

{"answer": 11, "explanation": "send(10) first advances the generator to `yield 1`, then resumes it with 10 as the result of that yield, 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 auto-key 0 yields 'ok', overwriting key 0, so the array is [0=>'ok', 1=>2]."}

{"answer": "noyes", "explanation": "The first call returns 'no' because the hash already uses cost 4, and the second returns 'yes' because cost 5 differs, so the outputs concatenate to 'noyes'."}

{"answer": "strict-in", "explanation": "E_ALL is 32767 (0x7FFF), which includes bit 2048 (E_STRICT), so 32767 & 2048 equals 2048, not 0."}

```json ⏎ {"answer": "mapped", "explanation": "Request::create stores the HTTP_X_TOKEN server entry, and Symfony builds the headers bag from HTTP_-prefixed server keys, so get('X-Token') returns 'abc'."} ⏎ ```

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

{"answer": "same", "explanation": "The EntityManager's identity map returns the same managed instance for both find() calls, and that instance is the already-persisted $u, so both object IDs match."}

{"answer": 0, "explanation": "Removing an entity that was persisted but never flushed cancels its scheduled insert, so nothing is written and the empty users table still has 0 rows."}

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

{"answer": "10,30,60", "explanation": "The window sum with ORDER BY id uses a running frame, giving running totals 10, 30, 60, which string_agg joins in id order."}

{"answer": "M1M2", "explanation": "The bus runs the first middleware, which echoes M1 and calls next(), then the second echoes M2, and the chain ends without error."}

{"answer": 11, "explanation": "HandleMessageMiddleware calls every handler registered for Ping since neither has a prior HandledStamp, so $n becomes 1 + 10 = 11."}

{"answer": 1, "explanation": "The unique index on column a makes the second INSERT of the value 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 rows exist inside the transaction and the count sees 2 before the transaction ends."}

{"answer": 6, "explanation": "The filter 'test_sum' substring-matches both test_sum and test_sum_abs, each with 3 data sets from prov(), giving 6 tests; test_other is excluded."}

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

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

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

{"answer": "invalid_client", "explanation": "RFC 6749 Section 5.2 defines invalid_client for client authentication failures, which include 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 is treated as empty, and the filter binds tighter than *, so 2 * 3 = 6."}

```json ⏎ {"answer": "TypeError", "explanation": "In Twig, ~ binds tighter than +, so this evaluates as ('a' ~ 1) + 2, which is \"a1\" + 2; PHP 8 throws a TypeError for arithmetic on a non-numeric string."} ⏎ ```

{"answer": 0, "explanation": "The value `['']` is a non-empty array, so NotBlank's `empty()` check fails to flag it and no violations are produced."}

{"answer": "invalid", "explanation": "Symfony's Form::isValid() returns false when the form has not been submitted, so no exception is thrown and 'invalid' is echoed."}

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

{"answer": "hi Bob!", "explanation": "On compile(), Symfony resolves %greeting% to 'hi %name%', then recursively resolves %name% to 'Bob', and the trailing '!' is kept."}

{"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 use !important with equal specificity, so the one defined later in Bootstrap's generated CSS wins; text-danger comes after text-primary in that file."} ⏎ ```

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

{"answer": 3, "explanation": "Domain depends on Application (PlaceOrder) and on Infrastructure twice (Db and the fully qualified Logger), and each dependency is reported separately, so there are 3 violations."}

{"answer": "10,15", "explanation": "The add method returns a new Money instance without modifying the original, so $a stays 10 and $c becomes 15."}

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

{"answer": "hi", "explanation": "PHP 8.4 and later accept calling a method directly on a `new` expression without wrapping it in parentheses, so `new C()->hi()` returns 'hi'."}

{"answer": "yesno", "explanation": "A new lazy ghost is uninitialized, so the first check prints 'yes'; reading $o->v runs the initializer, which sets v to 21 and marks the object initialized, so the second check prints 'no'."}

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

{"answer": "noyes", "explanation": "AnnotationClassLoader was deprecated in Symfony 6.4 and removed in 7.0, so class_exists returns false, while AttributeClassLoader still exists in 8.1 and returns true."}