Карта знаний PHP — bonsai-2:27b, run-29 · think: medium

{"answer": "no", "explanation": "Double-quoted strings support variable interpolation and a full set of escape sequences, while single-quoted strings do not, so they are processed differently, not just at different speeds."}

{"answer": "yes", "explanation": "The null coalescing operator (??) in PHP uses isset semantics, so it silently falls back to the right operand when the left operand is undefined or null, without raising any warnings or notices."}

{"answer": "ab", "explanation": "In PHP, the echo statement accepts multiple arguments separated by commas, and it outputs them concatenated together in sequence."}

{"answer": "yes", "explanation": "In PHP, print is a language construct that always outputs its argument and returns the value 1, which means it can be assigned or used within an expression (unlike echo, which has no return value)."}

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

{ ⏎   "answer": "no", ⏎   "explanation": "In PHP, the concatenation operator (.) actually has HIGHER precedence than addition and subtraction, so in an expression like $a + $b . $c, the concatenation $b . $c is evaluated first." ⏎ }

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

{"answer": "sum: 5", "explanation": "The + operator has higher precedence than the . concatenation operator, so the expression is parsed as 'sum: ' . (2 + 3), which equals 'sum: 5'."}

{"answer": "no", "explanation": "With ===, arrays must have the same keys and values in the same order to be considered equal; element order does matter."}

{"answer": "no", "explanation": "The == operator is a loose (non-strict) comparison, and 0 == false actually evaluates to true because false is type-cast to 0."}

{"answer": "no", "explanation": "In PHP 8, when comparing a non-numeric string with a number, the number is converted to a string and a string comparison is performed, so \"abc\" == \"0\" evaluates to false."}

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

{"answer": 42, "explanation": "PHP casts a string to an integer by parsing the leading numeric prefix and ignoring any trailing non-numeric characters, so '42abc' becomes 42."}

{"answer": 10, "explanation": "In PHP, the + operator converts both operands to numbers; '5' becomes 5 and 5 + 5 equals 10."}

{"answer": "no", "explanation": "In PHP, casting false to a string results in an empty string (\"\"), not \"0\"."}

{"answer": "yes", "explanation": "Due to floating-point precision issues, 0.1 + 0.2 equals approximately 0.30000000000000004, not exactly 0.3, so the strict equality comparison returns false."}

{"answer": "no", "explanation": "strrev() reverses a string byte-by-byte, which breaks multi-byte UTF-8 characters into invalid sequences, so it does not correctly reverse UTF-8 text."}

{"answer": "yes", "explanation": "The string 'Hello world' does contain the substring 'world', so str_contains() returns true."}

{"answer": "no", "explanation": "str_pad() can pad on the left (STR_PAD_LEFT), right (STR_PAD_RIGHT), or both sides (STR_PAD_BOTH) depending on the $type parameter, so it is not limited to the right side only."}

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

{"answer": 6, "explanation": "In UTF-8, 'h' is 1 byte, 'é' is 2 bytes, and each of 'l', 'l', 'o' is 1 byte, totaling 6 bytes which strlen returns."}

{"answer": "def", "explanation": "A negative start position in substr() counts from the end of the string, so -3 means starting at the third character from the end, yielding 'def'."}

{"answer": "no", "explanation": "In PHP, ucfirst() returns a new string with the first character uppercased and does not modify the original string, because PHP strings are value types, not references."}

{"answer":"yes","explanation":"In PHP, heredoc allows variable interpolation ($var), while nowdoc treats the content as a literal string with no interpolation."}

{"answer": "no", "explanation": "PHP's sort() resets numeric keys after sorting; use asort() instead to preserve key-to-value associations."}

{"answer":"yes","explanation":"In PHP, array keys that are strings which can be interpreted as integers (like '5') are automatically converted to their integer equivalent, so the key is stored as the integer 5."}

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

{"answer": "yes", "explanation": "array_filter() without a callback removes all falsy values (false, 0, 0.0, \"\", \"0\", [], null) from the array."}

{"answer": "no", "explanation": "By default, the $preserve_keys parameter of array_slice() is false, so it re-indexes the array starting from 0 instead of preserving original keys."}

{"answer": "[20, 30]", "explanation": "array_slice starts at offset 1 (value 20) and takes 2 elements, returning [20, 30]."}

{"answer": 2, "explanation": "The + operator unions arrays and keeps the left array's value for the duplicate 'a' key, resulting in two elements."}

{"answer": "yes", "explanation": "PHP 8.1 extended the spread operator in array context to work with arrays that have string keys, not just integer-keyed arrays."}

{ ⏎   "answer": "no", ⏎   "explanation": "In PHP 8.0+, named arguments and argument unpacking can be combined in a single function call, e.g., foo(a: 1, ...[2, 3]);" ⏎ }

{"answer": "no", "explanation": "In PHP, an anonymous function (closure) cannot access variables from the enclosing scope unless they are explicitly captured using the use keyword."}

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

{"answer": "no", "explanation": "The body of a PHP arrow function (fn) can only consist of a single expression (returned with `=>` or a single `return`/`echo` statement within curly braces), not several expressions."}

{"answer": "yes", "explanation": "In PHP 8.1+, arrow functions implicitly close over outer variables by reference, meaning the value is read at call time (lazily) rather than being snapshotted at definition time, just like regular closures without a `use` clause."}

{"answer": "yes", "explanation": "A static function closure in PHP is not bound to any object instance, so $this is not available in its scope and cannot be captured via use ($this)."}

{"answer": 5, "explanation": "The use ($x) keyword captures $x by value at the time the closure is created, so the closure always returns 5 regardless of the later reassignment."}

{"answer": "yes", "explanation": "In PHP weak (coercive) typing, the engine automatically casts the string \"5\" to the integer 5 when it is passed to an int-typed parameter."}

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, allowing parameters with visibility modifiers (private, public, protected) in the constructor to automatically create and assign class properties."}

{"answer": "final", "explanation": "In PHP, the 'final' keyword before a method declaration prevents it from being overridden in child classes."}

{"answer": "yes", "explanation": "In PHP, the 'final' keyword on a method prevents any subclass from overriding it."}

{"answer": "no", "explanation": "Private properties are only accessible within the class where they are defined and are not accessible from a subclass."}

{"answer":"class","explanation":"get_class() on an anonymous class instance returns a string like \"class\\0/path/to/file.php:N\" where \\0 is a literal NUL byte, so the part before the NUL byte is \"class\"."}

{"answer":"yes","explanation":"Private methods are hidden from child classes in PHP, so they are not part of the inheritance contract and a child class may freely define a method with the same name using any visibility."}

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

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

{"answer": "yes", "explanation": "In PHP, interfaces can declare constants (e.g., `const MY_CONST = 42;`), which are implicitly public and can be referenced via the interface name or an implementing class."}

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

{"answer": "yes", "explanation": "In PHP, interfaces can declare static methods, including abstract static methods (since PHP 5.5) and concrete static methods (since PHP 8.4)."}

{"answer": "no", "explanation": "The instanceof operator also returns true when the specified type is an interface that the object implements, so it is not limited to class inheritance."}

{"answer":"no","explanation":"In PHP, interface methods must be abstract (declare without a body) and cannot have default implementations; only traits can provide concrete method bodies."}

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared with either public or protected visibility, so a protected abstract method is perfectly valid."}

{"answer": 3, "explanation": "The cases() class method returns all enum cases, and Foo has three cases (A, B, C)."}

{"answer": "yes", "explanation": "Traits in PHP have supported constant declarations since PHP 5.3, allowing constants to be defined within the trait and accessed by classes that use it."}

{"answer": "yes", "explanation": "In PHP, both Exception and Error classes extend the abstract Throwable class, making it their common ancestor."}

{"answer":"no","explanation":"In PHP, TypeError inherits from Error, and Error and Exception are separate branches under Throwable, so catching Exception will not catch TypeError."}

{"answer": "no", "explanation": "The @ operator in PHP only suppresses errors, warnings, and notices, not exceptions, which are handled separately via try/catch/throw."}

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

{"answer": "no", "explanation": "The finally block executes regardless of whether an exception is caught, uncaught, or not thrown at all."}

{"answer": "no", "explanation": "An exception thrown in a finally block overrides the normal flow or the exception handled in the try/catch block and propagates outward, so it does have an effect."}

{"answer": "yes", "explanation": "In PHP, casting any object to boolean always results in true, because objects are inherently truthy."}

{"answer": "yes", "explanation": "According to the PHP documentation, functions registered with register_shutdown_function() are executed when the script terminates, including when exit() is called."}

{"answer": "no", "explanation": "The 'use' statement in PHP is a compile-time alias/namespace import; it does not load the class file. The class file is loaded at runtime via the autoloader when the class is actually referenced or instantiated."}

{"answer": "neither", "explanation": "In PHP, to import a function from a namespace you simply write `use Namespace\\function_name;` without the words \"function\" or \"const\"; the `const` keyword is reserved for importing constants."}

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 strips the mapped namespace 'App\\' leaving 'Controller\\Api\\UserController', which converts to the directory path 'Controller/Api/UserController.php' under the base path 'src/.'"}

{"answer": "yes", "explanation": "Including vendor/autoload.php calls spl_autoload_register() to register Composer's autoloaders for resolving classes."}

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

{"answer": "no", "explanation": "An unqualified class name in `new` is first resolved in the current namespace (prefixed by it); only if not found there does PHP fall back to the global root namespace."}

{"answer": "yes", "explanation": "Under PSR-4, the namespace App\\Model\\User maps to src/Model/User.php by stripping the root namespace 'App\\' and converting the remaining namespace components and class name into directory/file paths."}

{"answer": "no", "explanation": "In PHP, a `use` statement for importing a class or interface must be placed at the top level of a file or within a namespace; it cannot be written inside a function body."}

{"answer":"yes","explanation":"In PHP, array assignment by default creates a copy of the array (using copy-on-write optimization), so modifying one array does not affect the other unless an explicit reference (`&`) is used."}

{"answer": 2, "explanation": "In PHP, arrays are value types, so $b = $a creates a copy; modifying $b with $b[] = 3 does not affect $a, which still contains 2 elements."}

{"answer": "yes", "explanation": "In PHP, variables defined in the global scope are not automatically visible inside a function's local scope, so you must use the global keyword, $GLOBALS, or pass them as parameters to access them."}

{"answer": "no", "explanation": "$GLOBALS is a reference to the global scope, so unset($GLOBALS['x']) permanently removes the variable from the global scope for the rest of the script, not just within that function."}

{"answer": 6, "explanation": "The function inc() receives $n by reference, so the increment inside the function also modifies the original variable $n from 5 to 6."}

{"answer": "yes", "explanation": "In PHP, a by-value foreach does not make a complete snapshot of the array; it reads from the live array during iteration, so modifications to the array (e.g., changing unvisited elements or appending) are visible in the same pass."}

{"answer": "no", "explanation": "Static properties belong to the class itself and are shared among all instances; a change made through any instance is visible to every other instance of that class."}

{"answer":"no","explanation":"PHP arrays can only have integer or string keys; a boolean key like true is converted to the integer 1, not stored as a boolean."}

{"answer":"no","explanation":"While `return value;` can indeed be used inside a PHP generator to stop it, the Generator object does not have a `getReturn()` method to access that returned value."}

{"answer": "yes", "explanation": "PHP generators are rewindable; once exhausted, calling rewind() resets them so they can be traversed again."}

{"answer": "yes", "explanation": "The yield from construct in PHP delegates traversal to another generator or Traversable object, forwarding its values to the caller."}

{"answer":"Generator","explanation":"g() is a generator function, so calling g() returns a Generator object, and get_class() returns its class name string."}

{"answer": 3, "explanation": "The anonymous generator yields the three elements of [1, 2, 3] via yield from, and iterator_to_array collects all three into an array, so count returns 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (Last In, First Out) stack, not a FIFO queue; a FIFO queue in PHP is implemented by the SplQueue class."}

{"answer": "yes", "explanation": "ArrayIterator is a built-in PHP class that wraps an array and provides Iterator interface methods (current, next, key, valid, rewind) to traverse it."}

{"answer": "no", "explanation": "ArrayObject implements the Iterator interface, so it can be directly traversed with foreach."}

{"answer": "yes", "explanation": "password_hash() has no salt parameter; it generates and embeds the salt internally in the returned hash string automatically."}

{"answer":"no","explanation":"PASSWORD_DEFAULT in PHP 8 is set to 'argon2i' (falling back to 'bcrypt' if unavailable), not md5."}

{"answer": "yes", "explanation": "password_verify returns true (boolean) when the password matches the provided hash, and since 'secret' is the password used to generate the hash, it matches."}

{"answer": "no", "explanation": "strip_tags() removes HTML/XML tags to prevent XSS attacks, not SQL injection; SQL injection is mitigated with prepared statements or parameterized queries."}

{"answer": "yes", "explanation": "session_regenerate_id() generates a new session ID after login, invalidating the previous one and preventing an attacker from using a pre-set session ID to hijack the authenticated session."}

{"answer": "php_sapi_name", "explanation": "The php_sapi_name() function returns the name of the SAPI (Server API) that was used to load PHP, such as 'cli' for command-line execution."}

{"answer": "yes", "explanation": "session_destroy() only removes the server-side session data; the PHPSESSID cookie remains in the browser and must be deleted separately (e.g., with setcookie())."}

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

{"answer": "never", "explanation": "array_find() is not a built-in PHP function; it was never introduced in any PHP version."}

{"answer": "yes", "explanation": "PHP 8.4 introduced property hooks (get/set), allowing get and set methods to be declared within a class alongside a property without needing __get__/__set__."}

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

{"answer": "8.2", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2 to inform the compiler that a return value must not be discarded."}

{"answer": "N/A", "explanation": "PHP has never had a pipe operator |>; the bitwise OR operator | has existed since PHP 3.0, but there is no |> pipe operator in any PHP version."}

{"answer": "no", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) does not exist in any PHP version; PHP's clone has always been used as a simple language construct (clone $obj;)."}

{"answer": "no", "explanation": "array_first() and array_last() are not built-in PHP functions; they were never introduced in any PHP version."}

{"answer": "9.0", "explanation": "RFC Partial Function Application v2 was adopted for PHP 9.0."}

{"answer": "8.1", "explanation": "The clamp() function, as defined by the clamp_v2 RFC, was implemented in PHP 8.1."}

{"answer": "no", "explanation": "There is no known 'RFC Context Managers v2' in PHP's RFC process; this appears to be a fabricated RFC name."}

{"answer": "no", "explanation": "No such RFC called 'Bound-Erased Generic Types' was submitted or declined in 2026 for PHP; PHP has never pursued a generics system in this form."}

{"answer": "no", "explanation": "As of 2026, ZTS (Zend Thread Safety) remains an optional build option in PHP rather than the default, and no accepted RFC has made it the default due to the extensive ecosystem of extensions that would need ZTS compatibility."}

{"answer": "yes", "explanation": "PHP 8.5 (released November 2024) introduced property hooks and readonly property enhancements but did not add generics/parameterized types, which remain absent from the language."}

{"answer": "yes", "explanation": "This aligns with PHP's typical ~6-month minor release cycle, with 8.5 having been GA'd in late 2025 and 8.6 scheduled for late November 2026, making the statement true."}

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

{"answer": "no", "explanation": "The #[\\Deprecated] attribute RFC was not adopted for any PHP release; it went through multiple cycles of discussion and revision but was not finalized."}

{"answer": "yes", "explanation": "In clean/onion architecture, the dependency rule states that all dependencies point inward toward the center, so inner layers have no knowledge of or dependency on outer layers."}

{"answer": "yes", "explanation": "In DDD, domain entities must be framework-agnostic and pure, depending only on the language and standard library to keep the domain layer isolated from infrastructure like Doctrine or Symfony."}

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

{"answer": "business logic", "explanation": "In the Onion Architecture, the core business logic (domain rules) sits at the very center, with all other layers depending inward on it rather than outward."}

{"answer":"yes","explanation":"Tools like deptrac perform static analysis to detect and report forbidden cross-layer dependencies in PHP projects automatically."}

{"answer": "no", "explanation": "Passing an HTTP request or an EntityManager into a use case couples it to the framework and persistence layer, violating separation of concerns and making it harder to test and reuse; a use case should instead accept plain domain objects or commands and interact with persistence through an abstract repository interface."}

{"answer": "Repository", "explanation": "A Repository is a pattern from Domain-Driven Design that provides an in-memory collection of domain objects (aggregates/entities) while abstracting the storage mechanism behind an interface."}

{"answer": "yes", "explanation": "In clean architecture, the database is a detail in the outer layer (interfaces/adapters and frameworks/drivers), while the domain and use cases are inner layers that depend on abstractions, so swapping the database only affects the outer layer."}

{"answer": "no", "explanation": "An aggregate is a domain model concept representing a consistency boundary within the bounded context, whereas a database table is a persistence/storage structure; they are not the same thing and can map to each other in many-to-many or many-to-one relationships."}

{"answer": "yes", "explanation": "In Domain-Driven Design, Value Objects are defined as immutable and are considered equal if their field values match, regardless of object identity."}

{"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, the Aggregate Root is the single external entry point of an aggregate through which all changes must be made to maintain invariants."}

{"answer": "yes", "explanation": "In DDD, repositories are associated with aggregate roots (not individual entities), as the aggregate is the unit of consistency and the repository manages it as a whole."}

{"answer": "yes", "explanation": "In Domain-Driven Design, the Ubiquitous Language is indeed the common language shared between developers and domain experts for describing the domain and its model."}

{"answer": "domain", "explanation": "In model theory, the domain (or universe of discourse) of a model is the set of objects within which the language's symbols are interpreted consistently, and the same language can be interpreted over different domains yielding different models."}

{"answer": "no", "explanation": "DDD recommends a rich domain model where entities, value objects, and aggregates encapsulate business logic and invariants, rather than an anemic model where behavior is pushed into service classes."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a Bounded Context is explicitly a boundary within which a single model applies, and the same concept can be modeled as different classes in different contexts (e.g., 'Customer' in Sales vs. 'Customer' in Inventory)."}

{"answer":"yes","explanation":"Symfony's DI container instantiates services on first request (lazy loading) rather than eagerly at boot, unless explicitly marked as eager or a singleton requiring immediate creation."}

{"answer": "symfony:routes", "explanation": "The Symfony console command 'symfony:routes' lists all registered routes in the application."}

{"answer": "no", "explanation": "Symfony autowiring is designed precisely to eliminate the need for manually declaring every service; it automatically detects and registers services based on directory scanning, attributes, and conventions."}

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes (or PHP files) and stores them in a cache directory so they are reused across requests rather than being recompiled every time."}

{"answer": "yes", "explanation": "In Symfony's dev environment, the container is compiled and cached on first use, then only recompiled when tracked files change rather than on every request."}

{"answer": "SYMFONY_ENV", "explanation": "The SYMFONY_ENV environment variable is used to select the active Symfony environment (e.g., dev, prod)."}

{"answer": "yes", "explanation": "Symfony uses reflection with setAccessible(true) to invoke controller actions, so routing works with private (and any other visibility) methods of the controller class."}

{"answer": "no", "explanation": "PHP does not define an interface that gives event subscribers inherent priority over listeners; processing order is determined by explicitly assigned priorities, not by the subscriber/listener distinction."}

{"answer": "yes", "explanation": "The legacy Guard architecture (used from Symfony 2 through 5.2) was deprecated in 5.3 and removed in Symfony 6.0, replaced by the new Firewall architecture built on AuthenticatorInterface."}

{"answer":"IsGranted","explanation":"The #[IsGranted] attribute (Symfony\\Component\\Security\\Attribute\\IsGranted) checks whether the current user has the specified role or permission, returning a 403 Forbidden response if the check fails."}

{"answer": "yes", "explanation": "Voters are the component in Symfony's AccessDecisionManager used to make authorization decisions about whether a user is granted access to a specific resource, as illustrated by isGranted('EDIT', $post)."}

{"answer": "yes", "explanation": "Symfony 7 removed the annotation component, and the corresponding Doctrine 3 removed annotation-based ORM mapping, both in favor of PHP attributes."}

{"answer": "yes", "explanation": "Symfony automatically adds a CSRF token to forms and validates it on submission by default without any extra configuration."}

{"answer": "yes", "explanation": "Symfony always performs form validation on the server-side, regardless of whether client-side HTML5 validation passed or was bypassed."}

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

{"answer": "no", "explanation": "Symfony never stores passwords in plain text; it hashes them (typically using bcrypt via password_hash) and stores the hash, keeping only user identity in the session."}

{"answer": "yes", "explanation": "In modern Symfony projects, bundle configurations are placed in config/packages/ with one file per bundle or topic (e.g., config/packages/security.yaml), and these files are automatically loaded."}

{"answer": "yes", "explanation": "This is a common convention (e.g., in Laravel) where .env holds committed dev defaults and .env.local holds uncommitted real secrets, typically ignored via .gitignore."}

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

{"answer": "no", "explanation": "The Symfony container is frozen after compilation, so parameters cannot be modified at runtime with setParameter()."}

{"answer": "no", "explanation": "Since Symfony 3, services are non-public (public: false) by default and must be explicitly marked public to be fetched from the container."}

{"answer": "no", "explanation": "Many bundles in Symfony work with their default configurations and do not require a dedicated config file to function."}

{"answer": "yes", "explanation": "In Symfony, environment variable placeholders in configuration files like services.yaml use the %env(VAR)% syntax (written as %%env(VAR)%% in raw YAML) to inject the value of the corresponding environment variable."}

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable in Symfony enables debug mode, which activates the web profiler and Twig debug mode."}

{"answer": "no", "explanation": "In Symfony Messenger, a single message can have multiple handlers; all registered handlers for that message class or channel will be invoked."}

{"answer": "no", "explanation": "The sync transport processes the message immediately in the same process without queueing it, unlike async transports which place the message on a queue for a worker to pick up."}

{"answer":"bin/console messenger:consume","explanation":"In Symfony, the messenger:consume command starts a worker that processes queued messages from a Messenger transport."}

{"answer":"yes","explanation":"In Symfony Messenger, retry_strategy options (max_retries, time_limit, etc.) are defined per transport in the messenger configuration, allowing each transport to have its own retry behavior."}

{"answer": "yes", "explanation": "In Symfony Messenger, the default serializer used to encode and decode messages is JsonSerializer."}

{"answer": "false", "explanation": "There is no official 'Symfony Scheduler' component; Symfony does not ship a dedicated scheduler that produces and dispatches messages through Messenger—scheduling is typically handled externally (e.g., via cron) or through third-party packages."}

{"answer": "database", "explanation": "Symfony Messenger's 'database' transport uses Doctrine to store messages in database tables (messenger_messages and messenger_sent_messages)."}

{"answer":"yes","explanation":"Symfony's Messenger component allows you to add custom middleware to the pipeline with configurable priority to place them before or after built-in middleware."}

{ ⏎   "answer": "yes", ⏎   "explanation": "Symfony's documented release cycle states major versions every two years and minor versions every six months, with releases shipped in May and November." ⏎ }

{"answer": "8.2", "explanation": "Symfony 8 requires a minimum PHP version of 8.2."}

{"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations (validation, routes, and other annotation-based features), having already deprecated them in Symfony 6.0 in favor of PHP attributes."}

{"answer":"no","explanation":"AssetManager (mcbrae) is a pure-PHP asset manager that does not require Node/webpack, but it does not operate via an 'importmap.php' file; it serves assets through its own routes/API."}

{"answer": "no", "explanation": "Symfony 6.4 is actually a Long-Term Support (LTS) release, supported until November 2027, since all even-numbered major releases (4.4, 5.4, 6.4, 7.4) are LTS releases."}

{"answer": "no", "explanation": "Major Symfony releases remove the deprecations introduced in the previous branch, so they no longer exist or work in the new major version."}

{"answer": "yes", "explanation": "Symfony provides an UPGRADE guide for each major release, documenting all breaking changes and deprecations introduced in that version."}

{"answer": "asset-mapper", "explanation": "Symfony's AssetMapper component (Symfony\\Component\\AssetMapper) provides a pure-PHP solution for managing assets and generating the importmap without requiring node or webpack."}

{"answer": "no", "explanation": "Symfony 8.2 would not be released until around 2027, so it had not yet been released as of November 7, 2026."}

{"answer": "no", "explanation": "Following Symfony's six-month cycle from Symfony 6.0 (November 2024), November 2026 would be Symfony 7.1, not 8.2."}

{"answer": "8.2", "explanation": "Following Symfony's standard release cycle, the version that comes after 8.1 is 8.2."}

{"answer":"no","explanation":"Symfony 8.2 is a minor release (the '2' indicates the minor version), not a major release; only major releases like 8.0 introduce breaking API changes that would require rewriting applications."}

{"answer": "yes", "explanation": "PHP guarantees backward compatibility within a major version series, so upgrading from 8.1 to 8.2 (a minor bump within the 8.x branch) will not break existing code."}

{"answer": "8.4", "explanation": "Symfony 8.4 was the final minor release in the 8.x branch before Symfony 9.0 was released."}

{"answer": "yes", "explanation": "Symfony 8.2 requires PHP 8.5, so upgrading to it necessarily includes upgrading the PHP version."}

{"answer": "yes", "explanation": "In Symfony's deprecation policy, deprecations introduced in an 8.x minor release are scheduled for removal in the next major version, 9.0, meaning they are not removed before 9.0."}

{"answer": "no", "explanation": "Twig's {{ }} expression language is a restricted, sandboxed syntax that only permits predefined Twig functions, filters, and constructs — it does not allow calling arbitrary PHP code directly."}

{"answer": "yes", "explanation": "Twig applies the `html` escape filter to all output variables by default to prevent XSS, and it can only be overridden with the `|raw` filter."}

{"answer": "yes", "explanation": "By default, the Twig |e filter escapes a string for an HTML context, preventing issues like HTML injection."}

{"answer": "number_format", "explanation": "The twig/intl-extra package provides the number_format filter, which formats a number using the intl library according to the specified locale."}

{"answer":"yes","explanation":"In Twig, the |raw filter outputs a value without applying auto-escaping, which is the opposite of the default behavior."}

{"answer": "yes", "explanation": "In Twig, double curly braces {{ }} render the value of an expression, while percent curly braces {% %} delimit structural tags such as if, for, and set."}

{"answer": "no", "explanation": "Twig allows you to declare variables inside a template using the set tag, e.g. {% set my_var = 'hello' %}."}

{"answer": "dump", "explanation": "The Twig function `dump()` (e.g., {{ dump(myVar) }} or {{ myVar|dump }}) outputs the debug structure of a variable in a human-readable format."}

{"answer":"yes","explanation":"Bootstrap provides a pre-built set of CSS and JavaScript UI components (buttons, modals, navbars, etc.) and is not a SPA framework like React, Angular, or Vue."}

{"answer":"container","explanation":"In Bootstrap, the .container class provides a responsive container whose max-width increases at each breakpoint (e.g., 540px, 720px, 960px, 1140px)."}

{"answer": "no", "explanation": "The Bootstrap grid is split into 12 columns (not 16), and while Bootstrap 3 used CSS floats, Bootstrap 4 and 5 use Flexbox instead."}

{"answer": "yes", "explanation": "Bootstrap (versions 4 and 5) defines five named breakpoints: sm, md, lg, xl, and xxl."}

{"answer": "yes", "explanation": "In Tailwind CSS, utility classes like .mt-3 or .px-2 generate values that are the specified number multiplied by the base spacing unit (default 0.25rem), so .mt-3 equals 0.75rem and .px-2 equals 0.5rem."}

{"answer": "data-bs-toggle", "explanation": "The data-bs-toggle attribute is used in Bootstrap 5 to enable interactive components such as dropdowns, modals, and tooltips on elements."}

{"answer": "yes", "explanation": "Bootstrap 5 removed its jQuery dependency and its components (modals, dropdowns, tooltips, etc.) are built with vanilla ES6+ JavaScript."}

{"answer": "no", "explanation": "In Bootstrap 5, dark mode is enabled by adding the `data-bs-theme=\"dark\"` attribute to the root element, not by using a `.dark` class."}

{"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; you must explicitly create them using tools like Doctrine Migrations or the SchemaTool."}

{"answer": "persist()", "explanation": "EntityManager.persist() marks a new entity as managed and defers any SQL until flush() is invoked."}

{"answer": "yes", "explanation": "In Doctrine ORM 3, EntityManager::merge() takes a detached or unmanaged entity and makes it managed again, associating it with the current EntityManager so that changes can be flushed."}

{"answer": "yes", "explanation": "DQL (as used in JPA/JPQL) is object-oriented and references entity classes and their mapped fields rather than physical table and column names."}

{"answer": "null", "explanation": "In Doctrine ORM (and similar PHP ORM repositories), the find() method returns null when no entity matching the given primary key is found in the database."}

{"answer": "no", "explanation": "Symfony's DoctrineBundle does not automatically call flush() at the end of every request; developers must explicitly call flush() on the EntityManager when they want to persist changes to the database."}

{"answer": "yes", "explanation": "Once an entity is managed, the Unit of Work automatically tracks property modifications, so a flush() is all that's needed to persist the changes."}

{"answer": "no", "explanation": "In Doctrine ORM, remove() only marks the entity for deletion in the Unit of Work; the actual SQL DELETE is not executed until flush() is called."}

{"answer": "no", "explanation": "MVCC in PostgreSQL is specifically designed so that readers and writers do NOT block each other; readers see a snapshot at their transaction start and writers can proceed without waiting for readers."}

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

{"answer": "no", "explanation": "While both create an auto-incrementing sequence-backed column in PostgreSQL, they are distinct mechanisms: SERIAL is a PostgreSQL-specific shorthand (a column with a DEFAULT nextval() constraint), whereas GENERATED ... AS IDENTITY is a SQL:2003 standard feature with additional options (ALWAYS vs BY DEFAULT) and a different internal implementation."}

{"answer": "no", "explanation": "By default, PostgreSQL treats NULL values as not equal to each other, so a UNIQUE constraint allows multiple rows with NULL in the column."}

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

{"answer": "no", "explanation": "Plain VACUUM in PostgreSQL reclaims space for reuse within the table but does not return disk space to the operating system; only VACUUM FULL does that."}

{"answer": "PARTITION BY", "explanation": "In SQL window function definitions, PARTITION BY specifies the grouping of rows over which the window function is computed."}

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

{"answer": "yes", "explanation": "PostgreSQL's default mode is autocommit, meaning each SQL statement is executed and committed as its own implicit transaction unless you explicitly start one with BEGIN."}

{"answer": "COMMIT", "explanation": "The COMMIT statement is used to save all changes made within a transaction and permanently apply them to the database."}

{"answer": "yes", "explanation": "Indexes are used by the query optimizer for any statement that needs to locate rows via a WHERE condition on the indexed column, including UPDATE and DELETE, not just SELECT."}

{"answer": "yes", "explanation": "SAVEPOINT creates a named checkpoint within a transaction, and ROLLBACK TO <savepoint> undoes only the statements executed after that point without aborting the entire transaction."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query to gather real execution statistics (e.g., actual row counts and timing), whereas plain EXPLAIN shows the plan without executing."}

{"answer":"pgvector","explanation":"pgvector is a PostgreSQL extension that introduces vector types, distance operators, and index types (HNSW, IVFFlat) designed for embedding and vector similarity search."}

{"answer": "yes", "explanation": "A partial index only contains index entries for rows that match the WHERE condition, reducing index size and improving query performance on filtered data."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE via Serializable Snapshot Isolation (SSI), which uses a snapshot-based mechanism and conflict detection (dependency graph) rather than locking rows a transaction reads."}

{"answer": "yes", "explanation": "HTTP status 201 'Created' is returned when a resource has been successfully created in response to a request, such as a POST."}

{"answer": 204, "explanation": "HTTP 204 (No Content) indicates the request succeeded and the server is intentionally not returning a response body, commonly used after DELETE operations."}

{"answer":"yes","explanation":"Per RFC 7231 Section 4.1, the DELETE method is defined as idempotent, meaning a repeated request for the same resource produces the same outcome (e.g., a 410 Gone if already deleted)."}

{ ⏎   "answer": "no", ⏎   "explanation": "The Access-Control-Allow-Origin header is sent by the server in its response to inform the browser that it permits the requesting origin to access the resource, not the other way around." ⏎ }

{"answer": "yes", "explanation": "HTTP status 429 Too Many Requests is specifically defined in RFC 6585 as a response indicating the client has made too many requests in a given period of time, i.e., it has exceeded a rate limit."}

{"answer": "no", "explanation": "It's the other way around: 4xx codes indicate client errors, while 5xx codes indicate server errors."}

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that unlike PUT, PATCH is not required to be idempotent."}

{"answer":"no","explanation":"In PHP, you should use password_verify() (which performs a constant-time comparison and correctly handles the algorithm and cost embedded in the hash string) rather than a plain ==, which is vulnerable to timing attacks."}

{"answer":"yes","explanation":"A CSRF token is generated and stored on the server (tied to the session), then validated by server-side code on state-changing requests like POST, PUT, or DELETE to prevent cross-site request forgery."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to declare the set of resources from which a web page can load scripts and stylesheets."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol; it grants access to resources without requiring the user's credentials, and authentication is handled separately (e.g., via OpenID Connect)."}

{"answer": "no", "explanation": "XSS is prevented by proper output encoding/escaping when rendering data in HTML, not by input validation before storage; input validation does not guarantee that stored data is safe when later displayed in a browser context."}

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

{"answer": "yes", "explanation": "In OAuth 2.0, refresh tokens have a much longer expiry than access tokens and are specifically designed to exchange for a new access token without requiring the user to re-authenticate."}

{"answer":"no","explanation":"A password salt is not required to be secret; it is typically stored alongside the hash (e.g., in the database or encoded in the hash string) because its purpose is to defeat rainbow-table precomputation, not to provide secrecy."}

{"answer": "no", "explanation": "In PHPUnit, test classes must extend PHPUnit\\Framework\\TestCase (or a subclass) for the test runner to discover and execute the test methods."}

{"answer":"no","explanation":"setUp() runs before each individual test in the class; it is setUpBeforeClass() (a static method) that runs once before all tests of the class."}

{"answer": "no", "explanation": "A data provider is used to let a test run with multiple sets of arguments, not just one."}

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

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

{"answer": "yes", "explanation": "In PHPUnit 10, PHP attributes like #[DataProvider] replaced the old PHPDoc annotations, which were removed from support."}

{"answer": "no", "explanation": "PHPUnit does support test dependencies via the @depends annotation or the dependsOn() method, allowing one test to run after (and depend on the output of) another test."}

{"answer": "--random-order", "explanation": "PHPUnit provides the --random-order CLI option to shuffle and run test methods in a random order."}

{"answer": "3-4", "explanation": "intdiv(7, 2) equals 3 and intdiv(-7, 2) equals -4 (truncates toward negative infinity), so the concatenated string is \"3-4\"."}

{"answer": -9, "explanation": "The `**` operator has higher precedence than the unary `-`, so the expression is evaluated as `-(3 ** 2)` which equals -9."}

{"answer": "true", "explanation": "In PHP, the loose equality operator (==) converts numeric strings to numbers before comparing, so '1e1' (which equals 10) == '10' is true, resulting in the string 'true' being echoed."}

{"answer":"other","explanation":"In PHP, switch uses strict comparison (===), and the string 'a' does not match the integer 0, so it falls through to the default case which echoes 'other'."}

{"answer": "2c", "explanation": "strtr performs simultaneous replacements and uses the longest match at each position, so 'ab' (length 2) is replaced with '2' before 'a' (length 1) could match, leaving 'c' unchanged."}

{"answer": "[hello]", "explanation": "The string 'hello' is only 5 characters long, so starting at position -10 is before the start of the string; PHP clamps the start to 0 and returns the entire string 'hello'."}

{"answer": "k,n,m", "explanation": "The + operator merges arrays keeping the left value for duplicate keys, preserving order: k(1), n(2), m(3); array_keys returns ['k','n','m'] which implode outputs as \"k,n,m\"."}

{"answer": "yxz", "explanation": "usort sorts by the third element (index 2): values 1, 2, 2 → [2,'y',1], [1,'x',2], [3,'z',2], then array_column extracts the 'y', 'x', 'z' strings which implode into \"yxz\"."}

```json ⏎ {"answer": "4", "explanation": "The spread operator on an associative array unpacks values as named arguments, so it's equivalent to f(a: 5, b: 1), which returns 5 - 1 = 4."} ⏎ ```

{ ⏎   "answer": "SyntaxError", ⏎   "explanation": "The code `$p->g(...)` uses the spread operator `...` without a following array expression, which is a parse error in PHP." ⏎ }

{"answer": "B", "explanation": "static::class refers to the actual class of the object (late static binding), so it returns 'B' rather than 'A'."}

{"answer": 10, "explanation": "In PHP 8.5, property hooks are supported; the setter stores $value * 2 (5 * 2 = 10) in the backing property, and since no getter hook is defined, reading $c->x returns the raw backing value of 10."}

{"answer":"BA","explanation":"TB::f overrides TA::f for method f(), so f() returns 'B'; TA::f is aliased as g(), so g() returns 'A', giving the concatenated string 'BA'."}

{"answer": 0, "explanation": "Each class that uses a trait gets its own independent copy of the trait's static properties, so CY::$n remains 0 after CX::$n is set to 1."}

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

{"answer": "second", "explanation": "The RuntimeException in the inner try triggers the finally block, where a LogicException is thrown, which replaces the original exception and is caught by the outer catch handler."}

```json ⏎ {"answer": "App\\Foo|Baz", "explanation": "Baz::class resolves to App\\Foo (the alias defined by the use statement), while \\Baz::class resolves to Baz in the global namespace."} ⏎ ```

{"answer": "yesyes", "explanation": "class_exists('Foo') resolves 'Foo' against the current namespace Ns and finds Ns\\Foo (yes), and class_exists('Ns\\Foo') directly finds the class (yes), so the output is 'yesyes'."}

```json ⏎ {"answer": "1,2,99", "explanation": "Using foreach with a reference (&$v) makes $v a reference to the last element of the array even after the loop ends, so assigning 99 to $v modifies the third element of $a."} ⏎ ```

{"answer": "3", "explanation": "Static variables belong to the class (A), not individual instances; the three calls to inc() increment the same static counter, and the third call returns 3."}

{"answer": "", "explanation": "After $g->send(10) the generator is still paused at the yield statement and has not reached the return, so $g->getReturn() returns null, which echo prints as an empty string."}

{"answer": "1,2,ok", "explanation": "yield from inner() yields 1 and 2 from inner, then the return value 'ok' is stored in $r and yielded, so the generator yields 1, 2, 'ok', which implode joins into '1,2,ok'."}

{"answer": "noyes", "explanation": "The first check compares cost 4 with the existing cost 4 (no rehash needed), the second checks cost 5 against existing cost 4 (rehash needed)."}

```json ⏎ {"answer": "strict-out", "explanation": "In PHP 8.5, E_STRICT (2048) was removed from E_ALL (it was deprecated since 7.2 and removed in 8.3), so E_ALL & 2048 equals 0, making the ternary evaluate to 'strict-out'."} ⏎ ```

{"answer": "missing", "explanation": "The header key 'HTTP_X_TOKEN' does not match 'X-Token' even case-insensitively, so get('X-Token') returns null, making the ternary evaluate to 'missing'."}

{"answer":"BCA","explanation":"Symfony EventDispatcher calls listeners in order of descending priority (higher first), with a default priority of 0, so 'B' (10), 'C' (5), and 'A' (0) execute in that order."}

{"answer": "same", "explanation": "Doctrine ORM uses an identity map: after flush() the User is managed, so both find() calls hit the identity map and return the exact same object instance."}

{"answer": 0, "explanation": "persist() only adds the entity to the Unit of Work without issuing SQL; remove() detaches it before any INSERT is ever executed, so flush() has nothing to persist, leaving the table empty."}

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

{"answer": "10,30,60", "explanation": "The window function SUM(x) OVER (ORDER BY id) produces running sums (10, 30, 60), which are then concatenated by string_agg in order to form '10,30,60'."}

{"answer": "M1M2", "explanation": "The middleware stack processes M1 first (echoing 'M1'), which then delegates to M2 (echoing 'M2') before reaching the end of the stack."}

{"answer": 11, "explanation": "HandleMessageMiddleware calls all registered handlers for Ping::class, so both closures execute: $n goes from 0 to 1 to 11."}

{"answer": 1, "explanation": "The first INSERT succeeds, adding one row; the second INSERT hits the unique index constraint on column a but ON CONFLICT DO NOTHING silently skips it, so the table has 1 row."}

{"answer": 2, "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, the constraint is not checked until the transaction ends, so both inserts succeed and the count returns 2."}

{"answer": 6, "explanation": "The --filter option uses a regex match, so 'test_sum' matches both test_sum and test_sum_abs (each with 3 data points from the data provider), giving 3 + 3 = 6 tests."}

{"answer": "2, 1", "explanation": "The data provider supplies two datasets ([1] and [-1]), so two test cases are executed; only the case with -1 fails the assertTrue($x > 0) assertion."}

{"answer": "POST", "explanation": "The -d flag in curl sends the data as the body of a POST request by default."}

{"answer": "GET", "explanation": "The -G flag forces curl to send the request using the GET method, appending the -d data as a URL query string instead of a POST body."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.3, when the client_id is invalid (non-existent), the token endpoint returns the error 'invalid_client'."}

{"answer": "fragment", "explanation": "In the implicit grant (response_type=token), the access_token is returned in the fragment (the portion after #) of the redirect_uri, which prevents it from appearing in server logs."}

{"answer": 0, "explanation": "In Twig, the default filter only substitutes the fallback when the value is null; false is not null so it remains false, which is cast to 0 in arithmetic, giving 0 * 3 = 0."}

{"answer": "Twig\\Error\\CompileError", "explanation": "In Twig the `+` operator between a string ('a1') and an integer (2) raises a CompileError because mixed string/int arithmetic is not allowed."}

{"answer": 1, "explanation": "The empty string '' violates the NotBlank constraint, so validate() returns one violation and count() returns 1."}

```json ⏎ {"answer": "invalid", "explanation": "Calling isValid() on a form that has not been submitted simply returns false because isSubmitted() is false, so 'invalid' is echoed."} ⏎ ```

{"answer": "same", "explanation": "Symfony's compiled container caches service instances, so calling get('a') twice returns the same stdClass object, making both spl_object_id() calls equal."}

{"answer": "Throws an exception (ParameterNotFoundException): the parameter 'greeting!' was not found", "explanation": "In Symfony DI, the '!' before the closing '%' is part of the parameter name, so '%greeting!%' looks for a parameter named 'greeting!' which was never set (only 'greeting' was set)."}

{"answer": 720, "explanation": "At a 992px viewport, the lg breakpoint (>= 992px) is active, giving .container a max-width of 720px in Bootstrap 5.3."}

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

{"answer": 2, "explanation": "The Domain class depends on Application (PlaceOrder) and Infrastructure (Db), but Domain is only allowed to depend on Domain, so both are violations."}

```json ⏎ {"answer": 3, "explanation": "The class is in the Domain layer but depends on PlaceOrder (Application), Db (Infrastructure), and Logger (Infrastructure); since Domain may only depend on Domain, each of these three type references in the constructor violates the dependency rule."} ⏎ ```

{"answer": "10,15", "explanation": "$a has amount 10 and $c is a new Money created by adding 10 + 5, so $c->amount is 15; echoing them with a comma between produces '10,15'."}

{"answer": 1, "explanation": "remove() throws an exception before unset() executes, so the item 'a' is never removed and count() still returns 1."}

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

{"answer": "yesno", "explanation": "The first isUninitializedLazyObject check returns true (\"yes\") because the lazy ghost hasn't been accessed yet, and accessing $o->v triggers initialization (calling the closure to set $v=21), after which the second check returns false (\"no\")."}

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

{"answer": "noyes", "explanation": "Symfony 8.1 removed the AnnotationClassLoader (removed in Symfony 7.0), but includes the AttributeClassLoader (introduced in 6.3)."}