Карта знаний PHP — ornith-1.5:35b, run-18 · think: off

{"answer": "no", "explanation": "Double-quoted strings undergo variable interpolation and escape sequence processing while single-quoted strings are treated almost literally, so they are not processed identically and the difference is about processing, not just speed."}

{"answer": "yes", "explanation": "The ?? (null coalescing) operator follows isset semantics and does not raise a warning for undefined variables."}

{"answer": "ab", "explanation": "In PHP, the comma inside echo is a statement separator, not an argument delimiter, so multiple strings are output consecutively without a separator, printing 'ab'."}

```json ⏎ {"answer": "no", "explanation": "print always returns 1, but it is not a function and cannot be used inside an expression or with multiple arguments due to operator precedence."} ⏎ ```

{"answer": "no", "explanation": "The ?: (elvis) operator returns its left operand when it is truthy and the right operand when it is falsy."}

```json ⏎ {"answer": "false", "explanation": "In PHP, the concatenation operator (.) actually has higher precedence than addition and subtraction, not lower."} ⏎ ```

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

{"answer": "3", "explanation": "Due to operator precedence, concatenation (. ) has higher priority than addition (+), so 'sum: ' . 2 evaluates to 'sum: 2' first, then 2 + 3 is computed as the string 'sum: 2' is cast to int 2, resulting in 5, but PHP 8 uses the left operand's cast giving sum: 'sum: 2' + 3 where 'sum: 2' casts to 0+3=3."}

{"answer": "no", "explanation": "With strict comparison (===), two arrays are only equal if they have the same key/value pairs in the same order, so element order matters."}

{"answer": "no", "explanation": "The comparison 0 == false actually returns true because == performs a loose (non-strict) comparison, not a strict one, and 0 is loosely equal to false."}

{"answer": "yes", "explanation": "In PHP, a non-numeric string compared with a number using == undergoes type juggling where \"abc\" is converted to 0, so \"abc\" == 0 evaluates to true."}

```json ⏎ {"answer": "yes", "explanation": "Under PHP's loose comparison, null is considered equal to 0, the empty string (\"\"), and false all at the same time due to type coercion rules."} ⏎ ```

{"answer": 42, "explanation": "In PHP, casting a string starting with digits to int extracts the leading numeric portion, so '42abc' becomes 42."}

{"answer": "10", "explanation": "In PHP, when one operand is a string that looks like a number, it is converted to a number for arithmetic, so '5' + 5 evaluates to 10."}

{"answer": "no", "explanation": "When cast to string, false becomes an empty string (\"\"), not \"0\" (\"0\" is the string representation of the integer 0)."}

{"answer": "yes", "explanation": "Due to floating-point precision representation, 0.1 + 0.2 evaluates to 0.30000000000000004, which is not strictly identical (===) to 0.3."}

{"answer": "no", "explanation": "strrev() operates on bytes, not characters, so it breaks multi-byte UTF-8 strings by reversing the byte order and producing invalid characters."}

{"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 a string on the left, right, or both sides depending on the optional padding_type parameter (STR_PAD_LEFT, STR_PAD_RIGHT, or STR_PAD_BOTH)."}

{"answer": "false", "explanation": "By default, trim() removes all leading and trailing whitespace characters, including spaces, tabs, newlines, carriage returns, null bytes, and vertical tabs."}

```json ⏎ {"answer": "6", "explanation": "The string 'héllo' contains 5 characters, but 'é' is a multi-byte character in UTF-8 using 2 bytes, so strlen() counts 4 single-byte characters plus 2 bytes for 'é' = 6 bytes total."} ⏎ ```

{"answer": "def", "explanation": "substr with a negative start position counts from the end of the string, so -3 returns the last three characters 'def'."}

{"answer": "no", "explanation": "ucfirst() returns a new string with the first character capitalized and does not modify the original string, as strings in PHP are immutable and the function does not use a reference parameter."}

{"answer": "yes", "explanation": "Heredoc syntax processes variable interpolation and escape sequences like nowdoc, whereas nowdoc behaves like a single-quoted string and does not interpolate variables."}

{"answer": "no", "explanation": "The sort() function sorts the array by values and reassigns integer keys starting from 0, so it does not preserve the original key-to-value association."}

{"answer": "true", "explanation": "In PHP, array string keys that are valid decimal integers (like '5') are automatically converted to integers."}

{"answer": "no", "explanation": "The in_array() function uses loose comparison by default, and strict comparison (===) only occurs when the third optional parameter strict is explicitly set to true."}

{"answer": "yes", "explanation": "Without a callback, array_filter() removes all falsy elements (false, 0, \"\", null, array()) from the array by default."}

{"answer": "no", "explanation": "By default, array_slice() reindexes the numeric keys starting from 0 rather than preserving the original keys."}

{"answer": "[20, 30]", "explanation": "array_slice extracts the elements at offset 1 for a length of 2, returning values 20 and 30 from the array."}

{"answer": "2", "explanation": "The union operator (+) combines arrays but keeps the left-hand side values for duplicate string keys, so 'a' => 1 from the first array and 'b' => 2 from the second are retained, giving 2 elements."}

{"answer": "yes", "explanation": "Since PHP 8.1, the spread operator supports arrays with string keys, allowing them to be merged by key while numerically-indexed values are re-indexed."}

{"answer": "false", "explanation": "Named arguments can actually be combined with argument unpacking in a single call since PHP 8.1, where unpacked arrays containing named keys can be mixed with positional arguments."}

{"answer": "no", "explanation": "In PHP, anonymous functions (closures) have their own scope and cannot automatically access variables from the outer scope unless they are explicitly passed in via the use() keyword."}

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

{"answer": "no", "explanation": "When an arrow function's body consists of curly braces, it contains statements (which can include multiple statements), but this is called a 'block body', not multiple expressions; a concise body without braces must be a single expression."}

```json ⏎ {"answer": "no", "explanation": "In PHP, arrow functions capture outer variables by value implicitly at definition time, not by reference, unlike closures which require the `&` operator to capture by reference."} ⏎ ```

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "A static closure cannot access or capture $this because it is not bound to any object instance." ⏎ } ⏎ ```

{"answer": "5", "explanation": "Closure variable captures are by-value at the time the closure is declared, so $f captures $x=5 and does not see the later assignment to 7."}

{"answer": "yes", "explanation": "In weak/coercive typing mode, PHP automatically converts the string \"5\" to an integer when passed to a parameter declared as int."}

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, allowing properties to be declared and assigned directly within the constructor parameter list."}

{"answer": "final", "explanation": "The `final` keyword in PHP prevents a method or class from being overridden or extended in subclasses."}

{"answer": "yes", "explanation": "Declaring a method as final in PHP prevents any subclass from overriding it, which is the intended purpose of the final modifier."}

{"answer": "no", "explanation": "Private properties in a parent class are only accessible within that class itself and are not inherited or accessible in a subclass."}

```json ⏎ {"answer": "class@anonymous", "explanation": "get_class() on an anonymous class returns 'class@anonymous' followed by a NUL byte and the unique numeric identifier, so the part before the NUL byte is 'class@anonymous'."} ⏎ ```

{"answer": "true", "explanation": "Private methods are not part of the inheritance contract because they are not visible to child classes, so a child can freely declare a method with the same name and any visibility without being constrained by inheritance rules."}

```json ⏎ { ⏎ 	"answer": "yes", ⏎ 	"explanation": "__get() is only triggered when accessing non-existent properties, not for existing ones." ⏎ } ⏎ ```

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP throws an Error (specifically an Error of type 'Cannot modify a readonly property') because it violates a language feature rather than a runtime exception condition."}

{"answer": "yes", "explanation": "In PHP 7+, interfaces can declare and define constants, though prior to PHP 8 they could not have non-constant expressions."}

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

{"answer": "false", "explanation": "In PHP versions before 8.0, interfaces cannot declare static methods, and even in PHP 8.0+ where static methods in interfaces are allowed, the classic statement that interfaces declare only method signatures (implemented by classes) makes this false in the traditional sense."}

{"answer": "false", "explanation": "The instanceof operator in PHP checks whether an object is an instance of a class OR implements any of the specified interfaces, so it does not ignore interfaces."}

{"answer": "false", "explanation": "Interface methods cannot have a default implementation (prior to PHP 8.1 where only static methods can have defaults, but instance methods still cannot), whereas trait methods can have default implementations that can be overridden."}

{"answer": "yes", "explanation": "An abstract method's visibility is not constrained, so it can be declared as public, protected, or private."}

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

{"answer": "yes", "explanation": "Traits can declare constants in PHP, though when the trait is used in a class, any conflicting constant declarations with the class or other traits will result in a fatal error."}

{"answer": "yes", "explanation": "In PHP 7+, the Throwable interface is indeed the common ancestor of both the Exception class and the Error class, allowing both to be caught using a catch (Throwable $e) block."}

```json ⏎ {"answer": "no", "explanation": "TypeError implements Throwable and extends Error, but it does not inherit from Exception, so a catch (Exception $e) block will not catch it."} ⏎ ```

{"answer": "no", "explanation": "The @ operator in PHP suppresses errors (error_reporting), not exceptions, which are handled separately via try/catch blocks."}

{"answer": "DivisionByZeroError", "explanation": "In PHP 7+, intdiv() with a divisor of 0 throws a DivisionByZeroError, which is a subclass of ArithmeticError."}

{"answer": "false", "explanation": "The finally block always executes regardless of whether an exception occurred, was caught, or not."}

{"answer": "false", "explanation": "When an exception is thrown inside a finally block, it overrides and replaces the original exception/result from the try block, so it does affect the result."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, all objects (including Exception instances) are always truthy when cast to boolean, regardless of their content."} ⏎ ```

{"answer": "yes", "explanation": "register_shutdown_function() registers functions that execute when script termination is reached, including when exit() is called."}

{"answer": "no", "explanation": "The use statement only creates an alias for the class name; the class file is loaded lazily by the autoloader when the class is first used, not when the use statement is parsed."}

{"answer": "function", "explanation": "Functions are imported using the `function` keyword (e.g., `import { functionName } from './module'`), while `const` is used for variables and constants, not for importing functions."}

{"answer": "src/Controller/Api/UserController.php", "explanation": "The PSR-4 namespace prefix \"App\\\" maps to src/, so the fully qualified class name App\\Controller\\Api\\UserController translates to the file path src/Controller/Api/UserController.php with the class name in CamelCase and underscores converted to directory separators."}

```json ⏎ {"answer": "yes", "explanation": "The vendor/autoload.php file generated by Composer calls spl_autoload_register() to register the autoloaders that map class names to their file locations."} ⏎ ```

{"answer": "yes", "explanation": "__NAMESPACE__ is a magic constant that returns the name of the current namespace in PHP."}

{"answer": "false", "explanation": "In PHP, an unqualified class name in a new statement (like new Foo()) is resolved relative to the current namespace, not from the global root, so inside namespace App, new Foo() creates App\\Foo rather than \\Foo."}

{"answer": "yes", "explanation": "Under PSR-4, the namespace App\\ maps to src/, so App\\Model\\User corresponds to the file src/Model/User.php."}

{"answer": "yes", "explanation": "In PHP, a use statement for importing a namespace can be written inside a function body, and the import only applies within that function's scope."}

{"answer": "yes", "explanation": "In PHP, arrays are value types that are copied on assignment (copy-on-write), so assigning an array to a variable creates a separate copy rather than a reference."}

{"answer": "2", "explanation": "In PHP arrays are copied by value on assignment, so modifying $b does not affect $a."}

{"answer": "yes", "explanation": "In PHP, variables defined outside a function exist in the global scope and are not accessible inside a function unless declared with the global keyword, accessed via $GLOBALS, or passed as parameters."}

```json ⏎ {"answer": "no", "explanation": "Using unset($GLOBALS['x']) inside a function actually destroys the global variable x permanently, not just for the current function scope."} ⏎ ```

{"answer": "6", "explanation": "The function inc() modifies $n by reference using &$x, so $x++ increments $n from 5 to 6."}

```json ⏎ {"answer": "no", "explanation": "In PHP, a foreach loop iterating by value works on a copy of the array's internal structure, so modifications to the array inside the loop are not reflected in the current iteration pass (though the pointer continues)."} ⏎ ```

{"answer": "false", "explanation": "Static properties belong to the class itself rather than to individual instances, so a change made through one object IS visible in all other objects."}

{"answer": "no", "explanation": "In PHP, boolean array keys are automatically converted to integers (true becomes 1, false becomes 0), so they are not stored as booleans."}

{"answer": "yes", "explanation": "Generators support a return statement with a value, and PHP 7.0+ exposes it via the getReturn() method after the generator is exhausted."}

{"answer": "yes", "explanation": "The rewind() method resets a generator to its initial state, allowing it to be traversed again."}

{"answer": "yes", "explanation": "The `yield from` construct in PHP (since PHP 7.0) delegates traversal to another generator or iterable, allowing it to yield values from the delegated generator and handle send/throw operations."}

{"answer": "Generator", "explanation": "Since g() contains a yield statement, calling it returns a Generator object (which extends Iterator) without executing the body, and get_class() returns \"Generator\"."}

```json ⏎ {"answer": "3", "explanation": "The generator yields 3 elements (1, 2, 3) via `yield from`, and iterator_to_array collects all of them into a numerically indexed array, so count() returns 3."} ⏎ ```

{"answer": "no", "explanation": "SplStack implements a LIFO (last-in, first-out) stack, not a FIFO queue."}

{"answer": "yes", "explanation": "ArrayIterator is a PHP SPL class that wraps an array and allows traversing it via the Iterator interface along with additional array manipulation methods."}

{"answer": "false", "explanation": "ArrayObject implements the Traversable and IteratorAggregate interfaces, so it can definitely be traversed with foreach."}

{"answer": "yes", "explanation": "true, password_hash() automatically generates a cryptographically secure random salt when none is provided."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT in PHP 8 uses the bcrypt algorithm by default, not md5, and md5 is not salted and is considered cryptographically insecure for password hashing."}

```json ⏎ {"answer": "true", "explanation": "password_hash() generates a salted hash with a random cost factor, and password_verify() verifies the plaintext 'secret' against that generated hash, returning true because they match."} ⏎ ```

{"answer": "no", "explanation": "strip_tags() only removes HTML and PHP tags from strings and provides no protection against SQL injection, which requires proper input validation and the use of prepared statements or parameterized queries."}

{"answer": "yes", "explanation": "session_regenerate_id() with delete_old_session=true creates a new session ID, which prevents attackers from using a pre-set session ID to hijack a user's session after login."}

{"answer": "php_sapi_name", "explanation": "The built-in php_sapi_name() function returns the name of the SAPI (Server API Interface) being used, such as 'cli' for the command-line interface."}

{"answer": "yes", "explanation": "session_destroy() only removes the session data stored on the server; to delete the client-side session cookie, you must also unset the session cookie via setcookie() or session cookies."}

```json ⏎ {"answer": "no", "explanation": "session_start() must be called before $_SESSION can be populated or accessed, as it initializes the session."} ⏎ ```

{"answer": "8.1", "explanation": "The array_find() function was introduced in PHP 8.1 as part of the new array_* predicate functions."}

{"answer": "yes", "explanation": "Property hooks were introduced in PHP 8.4, allowing get, set, and other hooks to be defined directly within the property declaration."}

{"answer": "yes", "explanation": "Asymmetric visibility, allowing separate read and write access modifiers like private(set), was introduced in PHP 8.4."}

{"answer": "8.2", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2 to allow marking return values that should not be discarded."}

```json ⏎ { ⏎   "answer": "8.1", ⏎   "explanation": "The pipe operator (|>) first appeared in PHP 8.1 as part of the arrow function 2.0 RFC." ⏎ } ⏎ ```

```json ⏎ { ⏎   "answer": "8.3", ⏎   "explanation": "The clone syntax with reassignment (clone($obj, ['x' => 1])) was introduced in PHP 8.3 as part of the Parameterized Constructor Syntactic Sugar proposal." ⏎ } ⏎ ```

{"answer": "7.3", "explanation": "The array_first() and array_last() functions were introduced in PHP 7.3."}

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

```json ⏎ {"answer": "PHP 8.5", "explanation": "The clamp_v2 RFC, which introduces the clamp() function, was accepted and implemented in PHP 8.5."} ⏎ ```

{"answer": "no", "explanation": "RFC Context Managers was rejected by the PHP Council in June 2023 and has not been adopted as of 2026."}

{"answer": "false", "explanation": "RFC Bound-Erased Generic Types (generics) was not declined in 2026 because the 'Bound-Erased' proposal is a real PHP 8.0 feature, while the actually declined 2024 generics RFC was titled 'Bound-Generic Types'."}

{"answer": "false", "explanation": "There is no accepted RFC to enable Thread Safety Mode (ZTS) by default in PHP, as enabling ZTS by default would disable JIT and significantly reduce performance."}

```json ⏎ {"answer": "yes", "explanation": "PHP has no planned generics (parameterized types) as of PHP 8.5, since they were deliberately not implemented after PHP 5.1 due to their complexity and the language's dynamic typing."} ⏎ ```

{"answer": "yes", "explanation": "PHP release schedule follows ~8 month cycles with feature releases in November and maintenance patches, so PHP 8.5 (released November 2025) is the latest stable version in November 2026 while 8.6 GA would occur later."}

{"answer": "yes", "explanation": "PHP 6 was cancelled due to the Unicode rewrite project being abandoned, and after PHP 5.6 the next major release was PHP 7.0, so PHP 6 never actually shipped."}

```json ⏎ {"answer": "no", "explanation": "The RFC proposing the #[\\Deprecated] attribute was rejected, as core maintainers preferred the existing PHPDoc-based deprecation mechanism."} ⏎ ```

{"answer": "yes", "explanation": "In clean and onion architecture, dependencies correctly point inward from outer layers (which contain framework/UI concerns) toward inner layers (which contain business rules), ensuring inner layers remain independent of outer implementation details."}

{"answer": "true", "explanation": "Domain entities in Domain-Driven Design are meant to be pure PHP classes containing only business rules and standard library usage, intentionally independent of framework or ORM dependencies like Doctrine and Symfony."}

{"answer": "no", "explanation": "Controllers belong to the presentation/web layer (they handle HTTP concerns) while Twig templates belong to the view layer, not the business-logic layer which contains use cases and domain rules."}

{"answer": "Entities", "explanation": "In Onion Architecture, Entities sit at the very center as they contain enterprise business rules and are the least likely to change."}

```json ⏎ {"answer": "yes", "explanation": "Tools like deptrac analyze layer dependencies statically and fail the build when a forbidden cross-layer call is detected."} ⏎ ```

{"answer": "false", "explanation": "Use cases should depend only on abstractions (interfaces) that describe the minimal contract needed, not concrete types like HTTP requests or EntityManagers, to keep them decoupled from technical frameworks and easily testable."}

{"answer": "Repository", "explanation": "The Repository pattern provides a collection of aggregates or entities behind an interface while abstracting away the underlying storage mechanism."}

{"answer": "yes", "explanation": "In clean architecture, databases are implementation details isolated behind a gateway/framework boundary, so swapping them only affects the outer infrastructure layer while the domain and use cases remain unchanged."}

{"answer": "no", "explanation": "An aggregate in DDD is a cluster of domain objects treated as a single unit of logical data and consistency boundaries, not a database table, which is a physical storage concept unrelated to the domain model."}

{"answer": "yes", "explanation": "A Value Object is indeed immutable and compared by the values of its fields rather than by reference identity, which is the defining characteristic distinguishing it from an Entity."}

{"answer": "Factory Method", "explanation": "In DDD, the factory method serves as the single external entry point of an aggregate through which all changes and creation of new instances must occur, protecting the aggregate's invariants."}

{"answer": "yes", "explanation": "In DDD, repositories are declared only for aggregates by their root entity to enforce aggregate invariants and prevent external objects from manipulating child entities directly."}

{"answer": "yes", "explanation": "Ubiquitous language in Domain-Driven Design refers to the shared, precise vocabulary developed collaboratively by developers and domain experts that is used consistently throughout the software model and communications."}

{"answer": "Semantics domain", "explanation": "The semantics domain is the boundary within which a set of words and their meanings remain consistent with a model, while outside this boundary the same words take on different meanings under different models."}

```json ⏎ { ⏎   "answer": "false", ⏎   "explanation": "Anemic domain models are widely considered an anti-pattern in DDD; rich domain models that encapsulate behavior and enforce invariants within the entities themselves are the recommended approach." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "A bounded context in Domain-Driven Design establishes a explicit boundary within which a model is defined and meaningful, so the same concept (like 'Customer' or 'Product') can be represented as different classes in different bounded contexts to serve each context's specific needs."}

{"answer": "no", "explanation": "Symfony creates all services eagerly (lazily at compile time for the public container is misleading) — services are instantiated when requested, but the default behavior is not lazy creation on first use in the general sense; services are created when injected or fetched, though the container can create them upfront during container building for optimizability."}

{"answer": "bin/console debug:router", "explanation": "The `debug:router` command in Symfony's Console component lists all registered routes in the application."}

{"answer": "no", "explanation": "Symfony autowiring automatically infers and injects service dependencies without requiring you to manually declare every service in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes and caches them on disk to avoid recompiling between requests."}

{"answer": "true", "explanation": "In Symfony's dev environment, the container cache is only invalidated and rebuilt when tracked configuration or source files change, determined by a checksum comparison rather than on every request."}

{"answer": "SYMFUN_ENV", "explanation": "The Symfony app is initialized with the environment from the Symfony_env environment variable, defaulting to 'prod'."}

```json ⏎ {"answer": "yes", "explanation": "In Symfony, controllers can be any class with any public method (or callable), as long as the routing configuration points to it; however, private methods cannot be used as controller actions since Symfony invokes them via a callable that requires public visibility."} ⏎ ``` ⏎  ⏎ Wait, I need to reconsider this. The statement says "private" specifically. ⏎  ⏎ ```json ⏎ {"answer": "no", "explanation": "Symfony routing requires controller methods to be public, as private methods cannot be accessed or invoked from outside the class, making them unusable as controller actions."} ⏎ ```

{"answer": "no", "explanation": "Event subscribers and listeners in Symfony's EventDispatcher do not have inherent priority differences based on being subscribers, as priority is determined by the listener's priority value passed at registration, not by whether it is a subscriber."}

{"answer": "yes", "explanation": "In Symfony 6.0+, authentication is built on the newer authenticator system using AuthenticatorInterface, and the old Guard system has been removed."}

{"answer": "@IsGranted", "explanation": "The @IsGranted attribute (from Symfony Security bundle) checks a role or permission right on a controller method and returns HTTP 403 when the user lacks the required privilege."}

{"answer": "false", "explanation": "Voters are Symfony's mechanism for checking access, but 'EDIT' (all caps) is not a valid attribute—attributes are developer-defined strings like 'edit_post', and the example should be isGranted('edit_post', $post)."}

```json ⏎ {"answer": "yes", "explanation": "In Symfony 7+, validation constraints should be declared using PHP attributes rather than annotations, as Doctrine annotations were deprecated in Symfony 6 and removed in Symfony 7, with PHP 8 attributes becoming the recommended and supported approach."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default, generating and validating a token automatically when the 'csrf_protection' option (defaulting to true) is enabled."} ⏎ ```

{"answer": "yes", "explanation": "Symfony's form validation always runs server-side regardless of client-side HTML5 validation, since client-side checks can be bypassed."}

{"answer": "make:form", "explanation": "The `make:form` command in Symfony's MakerBundle scaffolds a new form class (FormType)."}

{"answer": "no", "explanation": "Symfony never stores the user's password in the session; it stores an authentication token, and passwords are hashed using a password hasher, never kept in plain text."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "In Symfony, bundle and third-party configuration is stored in the config/packages directory with one YAML file per bundle or configuration topic." ⏎ } ⏎ ```

{"answer": "false", "explanation": "This is backwards: .env.local is typically the non-committed file holding real secrets, while .env (or .env.dist/.env.example) contains safe defaults committed to the repository."}

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

{"answer": "false", "explanation": "In Symfony, the service container is compiled at build time, so setParameter() only works on the raw (uncompiled) container before compilation, not at runtime from a controller which uses the compiled container."}

{"answer": "no", "explanation": "By default, Symfony services are private (public: false), and you must explicitly mark them as public to fetch them directly from the container."}

{"answer": "no", "explanation": "Bundles work without a config file because they provide default configuration via their Extension class, making configuration optional rather than mandatory."}

{"answer": "yes", "explanation": "In Symfony, environment variables are injected into configuration files using the %env(VAR)% syntax, which is then resolved at runtime from actual environment variables or .env files."}

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable controls Symfony's debug mode, enabling the profiler and Twig debugging when set to true."}

```json ⏎ {"answer": "false", "explanation": "A single message in Symfony Messenger can have multiple handlers registered to process it simultaneously."} ⏎ ```

{"answer": "no", "explanation": "The sync transport sends messages and processes them immediately in the same request rather than queuing them for a separate worker."}

{"answer": "php artisan queue:work", "explanation": "The queue:work command starts a queue worker that consumes and processes messages from a queue, including those dispatched through Laravel's Messenger system."}

{"answer": "yes", "explanation": "In Symfony's Messenger, retry strategies (including retry attempts, multiplier, and delay) are configured per transport in the messenger configuration under the retry option."}

{"answer": "false", "explanation": "By default, Symfony Messenger serializes messages using PHP's native serialization, not JSON, which must be explicitly configured via the serializer's encoders."}

{"answer": "false", "explanation": "Symfony has no built-in 'Scheduler' component that dispatches messages through Messenger; scheduled tasks in Symfony use the `timer` feature (Symfony 7.2+) or the cron/mailer patterns, and the `symfony/clock` component manages time, not scheduling tasks to Messenger."}

{"answer": "DoctrineMessengerTransport", "explanation": "The Doctrine Messenger transport stores messages in database tables using Doctrine ORM."}

{"answer": "true", "explanation": "The Messenger pipeline supports custom middleware that can be placed before or after built-in middleware using tags like messenger.middleware and ordering priority."}

```json ⏎ {"answer": "no", "explanation": "Symfony major releases come every year (in November), not every two years."} ⏎ ```

{"answer": "PHP 8.4", "explanation": "Symfony 8 requires a minimum of PHP 8.4 as specified in its component composer.json files."}

{"answer": "yes", "explanation": "Symfony 7.0 removed support for using attributes in some contexts but kept backward compatibility with docblock annotations for validation and routing, so both annotation and attribute styles remain functional in Symfony 7.0."}

{"answer": "no", "explanation": "AssetMapper manages CSS/JS without node or webpack, but it uses assets.php (not importmap.php) to configure import mappings and vendor assets."}

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release, not a regular release, as it is one of the versions that receives extended support for three years plus bug fixes and security updates."}

{"answer": "no", "explanation": "Major releases do remove deprecations from the previous branch, as deprecations are typically cleaned up when moving to a new major version."}

{"answer": "yes", "explanation": "Symfony provides UPGRADE docs for each major (and minor) release, documenting the changes and migration steps."}

{"answer": "symfony/importmap", "explanation": "The Symfony Importmap component manages frontend assets via the modern importmap approach without requiring Node.js or Webpack."}

{"answer": "false", "explanation": "Symfony releases follow a fixed schedule with major versions released in November each year, so Symfony 8.0 would be released in November 2025, but there is no Symfony 8.2 release as major versions are only released annually in November."}

{"answer": "false", "explanation": "Symfony releases follow a predictable cycle with even-numbered minor versions (like 7.2) released in odd years (November 2026), while the next 8.x release would be scheduled for May 2027, not November 2026."}

{"answer": "8.2", "explanation": "Symfony follows a regular versioning cadence where major releases are numbered by year, so version 8.1 is followed by 8.2."}

{"answer": "no", "explanation": "Symfony 8.2 is not an existing release (Symfony versions are like 6.x/7.x), and the claim about requiring full rewrites for major releases is inaccurate since Symfony maintains backward compatibility within major versions."}

{"answer": "false", "explanation": "While PHP generally prioritizes backward compatibility within major versions (e.g., 8.1 → 8.2), it does remove deprecated features and occasionally introduces breaking changes, so code changes may still be required."}

{"answer": "8.4", "explanation": "Symfony follows a versioning scheme where the 8.x branch continues receiving minor versions through its LTS release, with 8.4 being the last minor version before Symfony 9.0 is released."}

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "Symfony 8.0 requires PHP 8.4, not 8.5, and there is no Symfony 8.2 version as of the current release schedule." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "Symfony's long-term support policy states that deprecations introduced in the 8.x branch will remain until Symfony 9.0, giving developers time to migrate."}

{"answer": "false", "explanation": "Twig's {{ }} syntax is only for outputting expressions, not for executing arbitrary PHP code blocks, which are restricted for security reasons."}

{"answer": "yes", "explanation": "Twig automatically escapes printed variables using the HTML escaper by default unless explicitly disabled with the |raw filter."}

{"answer": "yes", "explanation": "The Twig |e filter (equivalent to |html) escapes strings for safe HTML output by default."}

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

{"answer": "yes", "explanation": "The |raw filter in Twig marks a value as safe and disables auto-escaping for that value, though it is generally discouraged for security reasons."}

{"answer": "yes", "explanation": "In Twig, {{ }} is used for printing expression values while {% %} is used for executing tags like conditions, loops, and set."}

```json ⏎ { ⏎   "answer": "false", ⏎   "explanation": "Twig allows variable declaration inside templates using the set tag, e.g. '{% set x = 1 %}', so values don't only come from the controller." ⏎ } ⏎ ```

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

{"answer": "yes", "explanation": "Bootstrap is indeed a front-end framework providing pre-built CSS and JavaScript UI components like navbars, cards, and modals, rather than a single-page application framework like React, Vue, or Angular."}

```json ⏎ { ⏎   "answer": "container", ⏎   "explanation": "The .container class in Bootstrap provides a responsive container with fixed maximum widths that change per breakpoint." ⏎ } ⏎ ```

{"answer": "no", "explanation": "Bootstrap's modern grid (v4 and v5) is built on CSS Flexbox and uses a 12-column layout, not floats or 16 columns."}

{"answer": "false", "explanation": "Bootstrap's named breakpoints are sm, md, lg, xl, xxl, and the newest version adds xxxl, making six, not five."}

```json ⏎ {"answer": "yes", "explanation": "Bootstrap's spacing utilities (.mt-3, .px-2, etc.) use the spacing scale where each number corresponds to a multiple of the $spacer variable."} ⏎ ```

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the data-bs-toggle attribute (prefixed with \"bs\" to namespace it) enables interactive components like dropdowns, collapse, and modals on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 was rewritten to remove the jQuery dependency, using plain vanilla JavaScript instead."}

{"answer": "no", "explanation": "In Bootstrap 5.3, dark mode is enabled with the `data-bs-theme=\"dark\"` attribute on the root element (e.g., `<html>`), not with a `.dark` class."}

```json ⏎ {"answer": "no", "explanation": "Doctrine ORM does not automatically create database tables at runtime; table schema must be created explicitly using the schema-tool (e.g., the \"orm:schema-tool:create\" command) or migrations."} ⏎ ```

```json ⏎ { ⏎   "answer": "persist()", ⏎   "explanation": "The persist() method marks a new instance as managed and schedules it for insertion into the database, but no SQL is actually executed until flush() is called." ⏎ } ⏎ ```

```json ⏎ {"answer": "no", "explanation": "In Doctrine ORM 3, the EntityManager::merge() method was removed and is no longer available."} ⏎ ```

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is written in terms of entities and their fields rather than database tables and columns, which is one of its key advantages over raw SQL."}

{"answer": "null", "explanation": "When Doctrine's repository find() method cannot locate a record by the given identifier, it returns null rather than throwing an exception.", "explanation": "When Doctrine's repository find() method cannot locate a record by the given identifier, it returns null rather than throwing an exception."}

{"answer": "no", "explanation": "DoctrineBundle does not automatically call flush(); developers must explicitly call $entityManager->flush() to persist changes to the database."}

{"answer": "yes", "explanation": "For a managed entity, the Unit of Work tracks changes automatically, so a subsequent flush() will detect and persist the modification without needing an explicit persist()."}

{"answer": "yes", "explanation": "In Hibernate, the remove() method issues the SQL DELETE statement immediately (for the DELETE_STRATEGY), regardless of the flush setting."}

```json ⏎ {"answer": "no", "explanation": "PostgreSQL uses MVCC, but it is specifically designed so that readers do NOT block writers and writers do NOT block readers."} ⏎ ```

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command (or EXPLAIN ANALYZE variants in some databases) displays the execution plan a database optimizer would use without actually running the query."}

```json ⏎ {"answer": "no", "explanation": "SERIAL creates a sequence and integer column implicitly with a default nextval() value, while GENERATED ... AS IDENTITY uses the SQL-standard identity column mechanism with explicit generation clauses, so although both use sequences internally they differ in definition, behavior, and flexibility."} ⏎ ```

{"answer": "false", "explanation": "In PostgreSQL, a UNIQUE constraint allows multiple rows with NULL values in the column because NULLs are considered distinct from each other per SQL standard."}

{"answer": "string_agg", "explanation": "The string_agg() aggregate function in PostgreSQL concatenates values from multiple rows into a single string using a specified separator."}

{"answer": "no", "explanation": "Plain VACUUM does not return freed space to the operating system; it only reclaims space for reuse within the table, whereas VACUUM FULL is required to return space to the OS."}

{"answer": "PARTITION BY", "explanation": "The PARTITION BY clause in a window function's OVER clause divides rows into groups (partitions) that the function is computed over separately."}

{"answer": "no", "explanation": "The READ COMMITTED isolation level does not protect against non-repeatable reads; it only protects against dirty reads, while REPEATABLE READ is the level that prevents non-repeatable reads."}

{"answer": "yes", "explanation": "By default, PostgreSQL runs in autocommit mode, where each single SQL statement is automatically wrapped in its own transaction and committed immediately after it completes."}

{"answer": "COMMIT", "explanation": "The COMMIT command ends a transaction and permanently saves all changes made during it to the database."}

{"answer": "yes", "explanation": "Indexes not only speed up SELECT queries but also improve UPDATE and DELETE operations when they involve a search condition on an indexed column, since the index helps locate the target rows quickly."}

{"answer": "yes", "explanation": "True, PostgreSQL uses SAVEPOINT to create a marker within a transaction that can later be rolled back to with ROLLBACK TO SAVEPOINT, allowing part of a transaction to be undone without discarding the entire transaction."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports timing information in addition to showing the query plan."}

{"answer": "pgvector", "explanation": "pgvector is the open-source PostgreSQL extension that adds vector data types and index types (such as IVF, HNSW, and PQ) for efficient similarity search and embedding-based retrieval."}

{"answer": "yes", "explanation": "A partial index is built only over the subset of rows that satisfy the WHERE condition specified in the CREATE INDEX statement."}

{"answer": "no", "explanation": "In PostgreSQL, SERIALIZABLE is actually implemented using REPEATABLE READ isolation plus a mechanism that checks for serialization violations via the serialization failure and automatic retry, not by locking rows read (unlike some other databases that use predicate locking)."}

{"answer": "yes", "explanation": "HTTP 201 Created indicates that the request has been successfully processed and resulted in the creation of a new resource."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates the request succeeded but there is no response body to send back."}

{"answer": "yes", "explanation": "The DELETE method is idempotent because the first DELETE removes the resource and any subsequent DELETEs are also treated as successful, leaving the outcome (resource absent) unchanged."}

{"answer": "no", "explanation": "The Access-Control-Allow-Origin header is sent by the server, not the client, to indicate which origins are allowed to access the resource."}

{"answer": "yes", "explanation": "HTTP status 429 Too Many Requests is specifically defined by the IETF RFC 6585 to indicate that a user has sent too many requests in a given amount of time, i.e., has exceeded a rate limit."}

{"answer": "no", "explanation": "The statement is reversed: 4xx codes indicate client errors, while 5xx codes indicate server-side errors."}

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not required to be idempotent, unlike PUT, because PATCH may modify the resource in ways that are not safe to repeat."}

{"answer": "no", "explanation": "Comparing hashes with == is insufficient and vulnerable to timing attacks and type-juggling (e.g., `0e...` numeric string comparisons), so a constant-time comparison like hash_equals() should be used."}

{"answer": "yes", "explanation": "A CSRF token is indeed generated by the server, associated with the user's session, and validated server-side on unsafe HTTP requests such as POST to ensure the request originated from a legitimate source."}

```json ⏎ { ⏎   "answer": "Content-Security-Policy", ⏎   "explanation": "The Content-Security-Policy HTTP header allows site administrators to control which resources an environment can load. This header is a critical piece of web application defense in depth, helping to mitigate cross-site scripting (XSS) attacks in modern web browsers." ⏎ } ⏎ ```

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol; the OAuth 2.0 access token indicates what the client is authorized to do but does not inherently identify who the user is (that role belongs to OpenID Connect's ID token)."}

{"answer": "no", "explanation": "XSS is prevented by output encoding/escaping when rendering data to the browser, not by validating or sanitizing input before storing it in the database."}

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

{"answer": "yes", "explanation": "Refresh tokens have a longer lifespan than access tokens and are specifically designed to obtain new access tokens without requiring the user to reauthenticate."}

{"answer": "no", "explanation": "Password salts do not need to be secret—they are stored alongside the hash and are used during verification, and security relies on using unique salts per password, not on secrecy."}

```json ⏎ {"answer": "false", "explanation": "PHPUnit requires test classes to extend PHPUnit\\Framework\\TestCase (or use attributes/methods recognized by PHPUnit as test entry points), otherwise test methods are not executed."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "In PHPUnit, setUp() runs before each individual test method, not once before all tests (use setUpBeforeClass() with static for once-per-class setup)."} ⏎ ```

{"answer": "false", "explanation": "A data provider specifically allows a test to run with multiple sets of arguments, one iteration per returned data set."}

{"answer": "expectException()", "explanation": "The expectException() method in PHPUnit is used to declare an expectation that an exception of a given class will be thrown during a test."}

{"answer": "no", "explanation": "The statement is reversed: in PHPUnit, a mock verifies which methods were called while a stub only returns predetermined data."}

{"answer": "yes", "explanation": "In PHPUnit 10+, the #[DataProvider] attribute is the recommended approach while the @dataProvider annotation has been deprecated."}

{"answer": "false", "explanation": "PHPUnit supports test dependencies through the @depends annotation, which allows one test to depend on the result (and return value) of another test."}

{"answer": "--random-order-seed, --reverse-order-seed (via --order-by=random)", "explanation": "The `--order-by=random` option (with an optional `--random-order-seed`) is the PHPUnit CLI flag that makes tests run in random order."}

```json ⏎ {"answer": "3-4", "explanation": "intdiv(7,2) returns 3 (truncated toward zero) and intdiv(-7,2) returns -4 (also truncated toward zero), which concatenate to '3-4'."} ⏎ ```

```json ⏎ {"answer": "9", "explanation": "In PHP, the exponentiation operator ** has higher precedence than the unary minus, so -3 ** 2 is evaluated as -(3 ** 2), resulting in -9."} ⏎ ``` ⏎  ⏎ Wait, let me reconsider this carefully. ⏎  ⏎ ```json ⏎ {"answer": "-9", "explanation": "In PHP, the exponentiation operator ** has higher precedence than the unary minus operator, so the expression is parsed as -(3 ** 2) = -9."} ⏎ ```

{"answer": "true", "explanation": "Both operands are string literals that look like numbers, so PHP converts them to floats for comparison (1e1=10 equals 10), making the comparison true."}

```json ⏎ { ⏎     "answer": "other", ⏎     "explanation": "The switch compares 'a' (string) with 0 using loose comparison, but 'a' is not loosely equal to 0, so it falls to the default case which echoes 'other'." ⏎ } ⏎ ```

```json ⏎ {"answer": "abc", "explanation": "strtr() with an array uses the longest-match-first rule, so 'a' only matches if 'ab' doesn't, leaving 'abc' unchanged."} ⏎ ```

```json ⏎ {"answer": "[hello]", "explanation": "When the negative offset exceeds the string length, PHP treats it as 0, so substr returns the entire string 'hello', resulting in [hello]."} ⏎ ```

{"answer": "k,n,m", "explanation": "The array union operator (+) keeps keys from $a and appends new keys from $b not present in $a, resulting in keys k, n, m in order."}

```json ⏎ {"answer": "yzx","explanation": "usort sorts by the third element, grouping the equal '2' entries by their original order (stable sort), so order becomes [2,'y',1],[3,'z',2],[1,'x',2] and column 1 yields 'yzx'."} ⏎ ```

```json ⏎ {"answer": "4", "explanation": "The spread operator unpacks the associative array by key names, so $a receives 5 and $b receives 1, making the function return 5 - 1 = 4."} ⏎ ```

```json ⏎ { ⏎   "answer": "3", ⏎   "explanation": "The arrow function $f captures $p by value (a copy of the P object reference) at definition time, so even after $p is set to null, $f() still calls g() on the captured object returning 3." ⏎ } ⏎ ```

{"answer": "B", "explanation": "The who() method uses static::class, which returns the late-static-bound class name (B), not the class where the method is defined (A)."}

```json ⏎ {"answer": "10", "explanation": "The property accessor syntax used in the code is not valid PHP syntax (this feature was not included in PHP 8.5), so the code would produce a parse/syntax error rather than outputting 10."} ⏎ ```

{"answer": "BA", "explanation": "The alias `TB::f insteadof TA` resolves the conflict by giving `f()` the body of TB, and `TA::f as g` provides a separate `g()` method returning 'A', so output is 'B' followed by 'A'}

```json ⏎ {"answer": "0", "explanation": "Each class that uses the trait gets its own independent copy of the static property, so setting CX::$n = 1 does not affect CY::$n, which remains at its initialized value of 0."} ⏎ ```

{"answer": "2", "explanation": "In PHP, a finally block's return statement overrides any return from the try block, so f() returns 2."}

{"answer": "second", "explanation": "The inner RuntimeException thrown during try is suppressed when the finally block throws a new LogicException, which then propagates and is caught by the catch block echoing its message."}

{"answer": "N\\Baz|Baz", "explanation": "The alias Baz in namespace N refers to the namespaced class N\\Baz, while \\Baz explicitly refers to the global class Baz."}

{"answer": "yesyes", "explanation": "class_exists('Foo') resolves to 'Ns\\Foo' within the namespace and returns true, and the fully-qualified 'Ns\\Foo' also returns true, so both echo 'yes'."}

{"answer": "1,2,99", "explanation": "The reference `$v` from the foreach loop remains bound after the loop, so assigning 99 to `$v` modifies the last element (index 2) of the array."}

```json ⏎ {"answer": "1", "explanation": "Static variables are bound to the class where the method is declared (class A), so $a->inc() and $b->inc() both increment the same $n, resulting in $a->inc() returning 1."} ⏎ ```

```json ⏎ {"answer": "11", "explanation": "The send(10) method yields 10 as the value of the yield expression, so $x becomes 10, and returning $x + 1 gives 11, which getReturn() retrieves."} ⏎ ```

{"answer": "1,2,ok","explanation": "yield from delegates to inner() yielding 1 and 2, and the return value 'ok' becomes the value of the yield from expression, which is then yielded by outer()."}

{"answer": "yeno", "explanation": "The first call returns false because the hash already uses cost 4, while the second returns true because the cost parameter (5) differs from the hash's stored cost (4)."}

```json ⏎ {"answer": "strict-in", "explanation": "E_ALL always includes the E_STRICT flag (value 2048), so E_ALL & 2048 equals 2048, which is not equal to 0."} ⏎ ```

```json ⏎ {"answer": "mapped", "explanation": "Symfony's HeaderPrefixExtractor converts the server key HTTP_X_TOKEN to the header name X-Token and strips the HTTP_ prefix and underscores, so $r->headers->get('X-Token') returns 'abc'."} ⏎ ```

```json ⏎ {"answer": "ABC", "explanation": "Event listeners are sorted by descending priority, so priority 10 (B) runs first, then the default priority 0 (A), then priority 5 (C)."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "The EntityManager's first-level cache guarantees that two finds for the same identity return the same entity instance within a single unit of work."} ⏎ ```

```json ⏎ {"answer": "0", "explanation": "The entity is persisted then removed before flush, so the Unit of Work schedules a delete, and flush executes the DELETE, leaving the users table empty."} ⏎ ```

{"answer": "1", "explanation": "COUNT(x) counts only non-NULL values of x, so it returns 1 (ignoring the NULL row)."}

```json ⏎ {"answer": "10,30,60", "explanation": "The window sum s for each row is 10, 30, 60, and string_agg concatenates them in ORDER BY id into the comma-separated string \"10,30,60\"."} ⏎ ```

{"answer": "M2M1", "explanation": "Middlewares are executed in reverse order (last registered wraps first), so M2's tag echoes before M1's, and dispatch only passes through the middleware stack once in the forward direction."}

{"answer": "11", "explanation": "The HandleMessageMiddleware iterates through all registered handlers for the Ping message (d1 adding 1 and d2 adding 10) and invokes each, outputting 11."}

{"answer": "1", "explanation": "The two inserts of value 1 both target the unique-indexed column 'a', so the second ON CONFLICT DO NOTHING suppresses the duplicate, leaving exactly one row."}

```json ⏎ { ⏎   "answer": "1", ⏎   "explanation": "The unique constraint is deferred (DEFERRABLE INITIALLY DEFERRED), so it is not checked until COMMIT; since the transaction never commits, the check never fires, both inserts succeed, and the table contains 1 row." ⏎ } ⏎ ```

```json ⏎ { ⏎   "answer": "4", ⏎   "explanation": "The filter 'test_sum' matches both test_sum (3 data provider cases) and test_sum_abs (3 data provider cases), giving 6 total tests, not 4." ⏎ } ⏎ ```

```json ⏎ {"answer": "2, 1", "explanation": "The data provider prov() returns two test cases (x=1 and x=-1), so 2 tests run; x=1 passes assertTrue($x > 0) while x=-1 fails, so exactly 1 test fails."} ⏎ ```

```json ⏎ {"answer": "POST", "explanation": "The -d (--data) option in curl implicitly sets the request method to POST."} ⏎ ```

```json ⏎ { ⏎   "answer": "GET", ⏎   "explanation": "The -G flag tells curl to move the POST data into the URL query string and send it as a GET request instead of POST." ⏎ } ⏎ ```

{"answer": "invalid_client", "explanation": "According to RFC 6749 Section 5.2, when a client authentication fails at the token endpoint, the server must return an error response with error=\"invalid_client\"."}

{"answer": "fragment", "explanation": "With response_type=token (implicit flow), the access_token is returned in the URL fragment (the part after the #) so it is not sent to the server."}

{"answer": "0", "explanation": "Twig's default filter returns false itself (not 2) because the value is not null, so false*3 evaluates to 0."}

```json ⏎ {"answer": "Twig\\Error\\RuntimeError", "explanation": "The concatenation operator has higher precedence than addition, so Twig tries to add 2 to the resulting string 'a1', which is a non-numeric string, causing Twig\\Error\\RuntimeError when the expression is evaluated."} ⏎ ```

{"answer": "1", "explanation": "An empty string violates NotBlank, producing one violation."}

```json ⏎ {"answer": "Symfony\\Component\\Form\\Exception\\UnexpectedException", "explanation": "Calling isValid() on a form that has never been submitted triggers Symfony's unexpected exception because form validation requires the form to have been submitted first (or a token/csrf to be checked)."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "By default services are singletons (shared), so two calls to get('a') return the same instance."} ⏎ ```

```json ⏎ { ⏎   "answer": "hi Bob!", ⏎   "explanation": "The ContainerBuilder recursively parameter substitutions, so '%greeting%\' resolves to 'hi %name%' and '%name%' resolves to 'Bob', resulting in 'hi Bob!'." ⏎ } ⏎ ```

{"answer": "960px", "explanation": "In Bootstrap 5.3, the .container reaches its max-width of 960px at the lg breakpoint (≥992px) because it uses the previous breakpoint's width."}

{"answer": "text-primary", "explanation": "Since both classes appear in order, text-primary comes later in the source and overrides text-danger due to equal specificity and the last-match-wins rule."}

{"answer": "2", "explanation": "OrderService (Domain) imports two classes from forbidden layers: PlaceOrder (Application) and Db (Infrastructure), each counting as one deptrac violation."}

```json ⏎ {"answer": "2", "explanation": "PlaceOrder (Application) and Db (Infrastructure) are forbidden from depending on the Domain layer, so each import generates one deptrac violation."} ⏎ ```

```json ⏎ {"answer": "10,15", "explanation": "The add() method creates a new Money object with the summed amount (15) without modifying the original, so $a->amount stays 10 and $c->amount becomes 15."} ⏎ ```

```json ⏎ {"answer": "1", "explanation": "The remove() method throws a DomainException because only one item remains, so the item is never unset, leaving one item in the collection which count() returns."} ⏎ ```

{"answer": "hi", "explanation": "The code creates an instance of class C and immediately calls its hi() method which returns the string 'hi', then echoes it."}

{"answer": "yesno", "explanation": "newLazyGhost creates an uninitialized lazy ghost object (isUninitializedLazyObject returns yes), and merely reading $o->v triggers ghost initialization, after which it is no longer uninitialized (returns no)."}

```json ⏎ { ⏎     "answer": "no", ⏎     "explanation": "The AbstractGuardAuthenticator class was removed in Symfony 5.9 (the Guard component was deprecated in 5.3 and fully removed), so it does not exist in Symfony 8.1." ⏎ } ⏎ ```

```json ⏎ {"answer": "noyes", "explanation": "In Symfony 8.x the legacy AnnotationClassLoader was removed and the routing loader now uses attributes via AttributeClassLoader, so the first class no longer exists while the second one does."} ⏎ ```