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

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

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

{"answer": "ab", "explanation": "The echo statement with multiple comma-separated arguments outputs them consecutively without any separator, producing 'ab'}

{"answer": "false", "explanation": "print returns the value 1, but it can be used inside an expression since it is technically a language construct rather than a true function."}

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

{"answer": "false", "explanation": "In PHP 8, the concatenation operator (.) has the same precedence level as addition and subtraction, not a lower one."}

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

{"answer": "3", "explanation": "String concatenation (.) has higher precedence than addition (+), so it evaluates as ('sum: ' . 2) + 3, which is 'sum: 2' + 3, and since 'sum: 2' coerces to 0 numerically, the result is 0 + 3 = 3."}

```json ⏎ { ⏎  "answer": "no", ⏎  "explanation": "With strict comparison (===), arrays must have the same key/value pairs in the same order and of the same type to be considered equal." ⏎ } ⏎ ```

{"answer": "no", "explanation": "The comparison 0 == false returns true (not false) because == is the loose/equality operator (not strict ===), and in loose comparison 0 equals false."}

{"answer": "yes", "explanation": "In PHP 8, the loose equality comparison \"abc\" == 0 casts the string to a float (0.0) and the integer to float (0.0), making the comparison true."}

{"answer": "yes", "explanation": "Under PHP's loose comparison, null is loosely equal to 0, the empty string, and false simultaneously (as demonstrated by (null==0)==(null=='')==0==(null===null) being true)."}

{"answer": 42, "explanation": "In PHP, casting a string starting with digits to int extracts the leading numeric portion and ignores the trailing non-numeric characters."}

{"answer": "10", "explanation": "In PHP, when one operand is a numeric string and the other is a number, the string is converted to a number and arithmetic is performed, yielding 10."}

{"answer": "false", "explanation": "In PHP, when the boolean false is cast to a string it becomes an empty string (\"\"), not \"0\"; it is false as an integer that becomes \"0\"."}

{"answer": "yes", "explanation": "Due to floating point precision representation, 0.1 + 0.2 equals approximately 0.30000000000000004, which is strictly not === equal to 0.3."}

{"answer": "no", "explanation": "strrev() operates byte-by-byte, so it corrupts multi-byte UTF-8 characters by reversing their byte order."}

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

{"answer": "false", "explanation": "str_pad() can pad a string on the left, right, or both sides depending on the pad_type parameter (STR_PAD_LEFT, STR_PAD_RIGHT, or STR_PAD_BOTH)."}

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

{"answer": "6", "explanation": "strlen() counts bytes, not characters, and 'héllo' is 5 characters where 'é' is 2 bytes in UTF-8, totaling 6 bytes."}

{"answer": "cde", "explanation": "With a negative start position, substr counts from the end of the string and returns the substring from that position to the end, so 'abcdef' starting at -3 gives 'cde'."}

{"answer": "no", "explanation": "ucfirst() returns a new modified string without changing the original, as PHP strings are passed by value unless explicitly referenced."}

{"answer": "yes", "explanation": "Heredoc syntax processes variable interpolation like double quotes, while nowdoc syntax treats content literally without any interpolation."}

{"answer": "no", "explanation": "The sort() function sorts an array by value in ascending order but does not preserve the key-to-value associations as it reassigns numeric keys starting from 0."}

{"answer": "yes", "explanation": "In PHP, string keys that represent integers are automatically converted to integers when used as array keys."}

{"answer": "no", "explanation": "By default, in_array() uses loose comparison (==) rather than strict comparison (===), which requires the third optional parameter to be set to true."}

{"answer": "yes", "explanation": "Without a callback, array_filter() removes all falsy (empty) elements from the array, which is the documented default behavior."}

{"answer": "no", "explanation": "By default, array_slice() reindexes the numeric keys of the returned array starting from 0 unless the preserve_keys parameter is set to true."}

{"answer": "[20, 30]", "explanation": "array_slice extracts a portion starting at offset 1 with length 2, returning the elements at indices 1 and 2."}

{"answer": "2", "explanation": "The union operator (+) combines arrays keeping the left side's keys for collisions, so the result is ['a' => 1, 'b' => 2], which has 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 extended the spread operator to support arrays with string keys, allowing both numeric and string keys to be merged correctly."}

{"answer": "false", "explanation": "Named arguments can be combined with argument unpacking in a single call since PHP 8.1 allows named arguments in unpacked arrays."}

{"answer": "no", "explanation": "In PHP, anonymous functions (closures) do not automatically access outer scope variables; you must explicitly pass them using the use keyword."}

{"answer": "3", "explanation": "func_num_args() returns the total number of arguments passed to the function, which is 3 when called as f(1, 2, 3)."}

{"answer": "no", "explanation": "Arrow functions with curly braces contain a block body that requires explicit return statements if a value should be returned, whereas only expressions (without braces) are implicitly returned."}

{"answer": "false", "explanation": "Arrow functions capture outer variables by value (by copy), not by reference, so modifications to the outer variable inside the arrow function do not affect the original."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "Static closures explicitly cannot access $this and will throw an error if $this is referenced inside them." ⏎ } ⏎ ```

{"answer": "5", "explanation": "Variables captured by value in a closure use the value at the time the closure was created (5), not the later reassigned value (7)."}

{"answer": "yes", "explanation": "In weak typing mode, PHP performs implicit coercion so the string \"5\" is automatically converted to the integer 5 when passed to an int parameter."}

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, which allows declaring and assigning properties directly within the constructor parameter list."}

{"answer": "final", "explanation": "The `final` keyword prevents a method from being overridden by subclasses."}

{"answer": "yes", "explanation": "In PHP, a method declared with the final keyword cannot be overridden by any subclass, which is exactly the purpose of the final modifier."}

{"answer": "no", "explanation": "Private properties are accessible only within the defining class itself and are inherited but not directly accessible in a subclass."}

{"answer": "class@anonymous\\0", "explanation": "Anonymous classes in PHP have a generated name in the format 'class@anonymous\\0<file_path>:<line>', and get_class returns this name including the NUL byte that terminates the string."}

{"answer": "yes", "explanation": "In PHP, private methods are not part of the inheritance contract, so a child class may declare a method with the same name as a private parent method with any visibility without error."}

```json ⏎ { ⏎ 	"answer": "yes", ⏎ 	"explanation": "The __get() magic method is triggered only when attempting to read a property that does not exist or is inaccessible." ⏎ } ⏎ ```

{"answer": "Error", "explanation": "Reassigning a readonly property throws an Error (specifically a TypeError), not an Exception."}

{"answer": "yes", "explanation": "Interfaces can declare constants since PHP 7.1, and they are implicitly public and static."}

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

{"answer": "false", "explanation": "In PHP versions before 8.0, interfaces could not declare static methods, and while PHP 8.0+ does allow static method declarations in interfaces, the classic/standard answer to this statement is false because interfaces traditionally define instance method contracts that implementers must provide."}

{"answer": "false", "explanation": "The instanceof operator checks both class inheritance and interface implementation, so it does not ignore interfaces."}

{"answer": "no", "explanation": "Interface methods cannot have a default implementation in PHP versions before 8.1, and even with default interface methods introduced in PHP 8.1, they are not identical to trait methods since interface default methods can only call other interface methods via $this while trait methods have full access to the consuming class's properties and methods."}

{"answer": "yes", "explanation": "Abstract methods can have any visibility (public, protected, or private), so an abstract method in an abstract class may indeed have protected visibility."}

```json ⏎ {"answer": 3, "explanation": "The `cases()` method of a PHP BackedEnum or UnitEnum returns all the defined cases as an array, and here three cases (A, B, C) are defined."} ⏎ ```

{"answer": "yes", "explanation": "Traits can declare constants in PHP."}

{"answer": "yes", "explanation": "The Throwable interface is the common ancestor of both Exception and Error in PHP 7+"}

```json ⏎ {"answer": "no", "explanation": "TypeError inherits from Error, not Exception, so a catch (Exception $e) block will not catch it unless it also catches Error."} ⏎ ```

{"answer": "no", "explanation": "The @ operator suppresses errors (warnings/notices), not exceptions, which are controlled separately via try/catch blocks."}

{"answer": "ArithmeticError", "explanation": "intdiv(5, 0) throws an ArithError because dividing an integer by zero is an unsupported operand error in PHP."}

{"answer": "no", "explanation": "The finally block always runs regardless of whether an exception was caught, thrown, or the code completed normally."}

{"answer": "false", "explanation": "An exception thrown inside a finally block replaces the original return value or exception from the try block, so it does affect the result."}

{"answer": "yes", "explanation": "Any object in PHP, including an Exception instance, always evaluates to true when cast to boolean, regardless of the exception's message."}

{"answer": "yes", "explanation": "Registered shutdown functions execute when the script exits normally, via exit(), die(), reaching the end of the script, or on a fatal error, so they do run when exit is called."}

{"answer": "false", "explanation": "The use statement only creates an alias for a class name; it does not load the class file, which is done by an autoloader when the class is first referenced."}

{"answer": "no", "explanation": "In PHP, functions are imported using 'use function', while classes use 'use', so the word 'function' (not 'const') is used to import a function."}

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps the namespace separator \\ to a directory separator, so App\\Controller\\Api\\ becomes src/Controller/Api/ with the class name appended as UserController.php."}

{"answer": "yes", "explanation": "vendor/autoload.php generated by Composer registers autoloaders using spl_autoload_register()."}

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

{"answer": "false", "explanation": "An unqualified class name in `new` is resolved relative to the current namespace, not the global root, so it would fail to find classes defined in the global namespace unless they exist in the current namespace."}

{"answer": "yes", "explanation": "Under PSR-4, the namespace App\\ maps to src/, so App\\Model\\User maps to src/Model/User.php with the namespace separator converted to directory separators."}

{"answer": "yes", "explanation": "In PHP 7 and later, use statements can be written inside function or method scopes, where they apply only within that function's scope."}

{"answer": "yes", "explanation": "In PHP, arrays use copy-on-write semantics, so assigning an array to another variable creates a copy rather than passing it by reference."}

{"answer": "2", "explanation": "In PHP 7, arrays are value types, so assigning $b = $a creates an independent copy, and modifying $b does not affect $a."}

{"answer": "yes", "explanation": "In PHP, user-defined global variables are function-scoped and cannot be accessed inside a function without explicitly using the global keyword, the $GLOBALS array, or passing them as parameters."}

{"answer": "false", "explanation": "Using unset() on $GLOBALS['x'] inside a function removes the global variable entirely from $GLOBALS, not just for that function's scope."}

{"answer": "6", "explanation": "The function inc() modifies $n by reference, incrementing its value from 5 to 6."}

{"answer": "false", "explanation": "A foreach that iterates by value works over a copy of the array, so modifications to the array inside the loop are not visible in the same pass."}

{"answer": "false", "explanation": "Static properties belong to the class itself and are shared across all instances, so changes made through one object are visible in others."}

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

{"answer": "yes", "explanation": "A generator can return a value with 'return $value;', and Generator::getReturn() retrieves it after the generator has completed by calling getCompletedValue() first."}

```json ⏎ {"answer": "yes", "explanation": "Calling rewind() on a fully consumed Generator resets it to the beginning, allowing it to be traversed again."} ⏎ ```

{"answer": "yes", "explanation": "In Python, `yield from` delegates traversal to another generator or iterable, allowing it to yield values from the sub-iterable and forward sent values."}

```json ⏎ {"answer": "Generator", "explanation": "A function containing the yield keyword is compiled into a Generator class rather than a regular function, so calling g() returns a Generator instance whose class name is \"Generator\"."} ⏎ ```

{"answer": "3", "explanation": "The generator yields 3 elements from the array [1, 2, 3], and iterator_to_array combined with count will return all 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (Last In First Out) stack, not a FIFO queue; that behavior is provided by SplDoublyLinkedList with SplQueue or SplDoublyLinkedList::MODE_QUEUE mode."}

{"answer": "yes", "explanation": "ArrayIterator is a PHP SPL class that wraps an array and allows it to be traversed using the Iterator interface."}

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

{"answer": "yes", "explanation": "password_hash() generates a random salt automatically and stores it within the returned hash, so passing a separate salt is unnecessary."}

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT uses bcrypt by default, not md5, and md5 is an insecure hash that should never be used for password storage."}

```json ⏎ { ⏎   "answer": "true", ⏎   "explanation": "password_hash generates a unique salt each time, but password_verify correctly compares the plaintext 'secret' against the hashed version and returns true (a boolean, output as 'true')." ⏎ } ⏎ ```

{"answer": "no", "explanation": "strip_tags() removes HTML and PHP tags from strings and is used against XSS attacks, not SQL injection, which requires parameterized queries or escaping."}

```json ⏎ {"answer": "yes", "explanation": "session_regenerate_id() regenerates the session identifier, which is the recommended defense against session fixation attacks, especially upon user privilege changes like login."} ⏎ ```

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

```json ⏎ {"answer": "yes", "explanation": "session_destroy() only removes the session data stored on the server side; it does not delete the session cookie stored in the user's browser, which would need to be explicitly cleared using unset() on $_COOKIE or by setting the cookie to expire."} ⏎ ```

{"answer": "false", "explanation": "The $_SESSION array is only populated after session_start() is called, which initializes the session and loads any stored session data into the array."}

{"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3, released in December 2018."}

{"answer": "yes", "explanation": "Property hooks (get/set in property declaration) were indeed introduced in PHP 8.4."}

{"answer": "yes", "explanation": "Asymmetric visibility, allowing different access levels for reading and writing via set, was introduced as a feature in PHP 8.4."}

```json ⏎ { ⏎   "answer": "8.2", ⏎   "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2 as part of the discardable expressions feature that warns when the return value of a function is ignored." ⏎ } ⏎ ```

{"answer": "8.1", "explanation": "The pipe operator (|>) was introduced in PHP 8.1 as an experimental feature, later made permanent."}

```json ⏎ { ⏎   "answer": "PHP 8.2", ⏎   "explanation": "The clone syntax with an arguments list, such as clone($obj, ['x' => 1]), was introduced in PHP 8.2 as a shorthand for object cloning with property overrides." ⏎ } ⏎ ```

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

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

{"answer": "8.4", "explanation": "The clamp() function was implemented in PHP 8.4, as introduced by the clamp_v2 RFC approved in 2024."}

{"answer": "no", "explanation": "RFC Context Managers (destructors via __destruct) was indeed adopted in PHP 8.2, but the more restrictive 'Context Managers v2' RFC proposing a __context__ magic method was rejected by the PHP Engineering Council in 2024 and never adopted."}

{"answer": "false", "explanation": "PHP's generics (called \"Generics\" or RFC-bound erased generics) were proposed and discussed around 2023-2024, not declined in 2026."}

{"answer": "false", "explanation": "As of now there is no accepted RFC to make Thread Safety (ZTS) the default in PHP, and PHP's default compilation remains Non-Thread-Safe (NTS)."}

```json ⏎ {"answer": "yes", "explanation": "As of PHP 8.5 (released November 2025), generics/parameterized types have not yet been implemented in PHP and remain a commonly requested feature."} ⏎ ```

{"answer": "yes", "explanation": "As of November 2026, PHP 8.5 is indeed the latest stable release and PHP 8.6 has not yet reached general availability."}

{"answer": "yes", "explanation": "PHP 6 was cancelled/abandoned and PHP 7.0 was released directly after PHP 5.6 without PHP 6 ever shipping."}

{"answer": "false", "explanation": "The RFC proposing the #[\\Deprecated] attribute was rejected by the PHP Core on 2024-11-14 and another version was rejected again on 2025-05-30."}

{"answer": "yes", "explanation": "In clean and onion architecture, inner layers must not know about outer layers; dependencies point inward toward the center, with outer layers depending on inner ones."}

{"answer": "true", "explanation": "In domain-driven design, domain entities should be pure PHP code free of framework dependencies like Doctrine and Symfony, so they can be reused and tested independently."}

{"answer": "false", "explanation": "Controllers are part of the application/presentation layer (not business logic), and Twig templates are part of the presentation view layer, so neither belongs to the business-logic layer."}

{"answer": "Entities", "explanation": "In the Onion Architecture, Entities sit at the very center as the innermost layer, containing business rules and domain objects."}

{"answer": "yes", "explanation": "Yes, because static analysis tools like deptrac detect and fail on forbidden cross-layer calls, enforcing layer boundaries automatically."}

```json ⏎ {"answer": "no", "explanation": "A well-designed use case should accept plain domain inputs rather than framework-specific objects like HTTP requests or an EntityManager, which would couple the use case to infrastructure layers and break its reusability and testability."} ⏎ ```

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

{"answer": "yes", "explanation": "In clean architecture, databases are an implementation detail in the outer infrastructure layer via the dependency inversion principle, so swapping databases only affects that layer while the domain and application (use cases) remain unchanged."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of domain objects treated as a single unit with bounded consistency and invariants, not merely a database table (which is an implementation detail)."}

{"answer": "yes", "explanation": "Value Objects are designed to be immutable and compared by the values of their fields rather than by reference identity, which is the defining characteristic distinguishing them from entity objects."}

{"answer": "Gateway", "explanation": "In Domain-Driven Design, the Gateway is the single external entry point of an aggregate through which all changes must pass to enforce invariants and consistency."}

{"answer": "yes", "explanation": "In DDD, repositories are created for aggregates to prevent callers from accessing or modifying entities inside an aggregate without going through the aggregate root, thereby preserving invariants."}

{"answer": "yes", "explanation": "Ubiquitous language in Domain-Driven Design refers to the shared, common language developed and used by both developers and domain experts to describe the domain consistently throughout the software model."}

{"answer": "semantic boundary", "explanation": "This is the terminology for the boundary where a model and its language remain consistent while outside it the same words refer to other models."}

```json ⏎ {"answer": "false", "explanation": "Anemic domain models are considered an anti-pattern in DDD because they violate encapsulation by placing business rules in services instead of keeping them inside value objects and entities that own their own state."} ⏎ ```

{"answer": "yes", "explanation": "A bounded context defines an explicit boundary within which a domain model applies, and the same concept (like 'Product' or 'Customer') is represented by distinct classes in different bounded contexts to avoid unintended coupling."}

{"answer": "no", "explanation": "In Symfony's DI container, services are created eagerly (all instantiated) when the container is compiled/cleared, not lazily on first use."}

{"answer": "debug:route", "explanation": "The Symfony console command that lists all registered routes is debug:route."}

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "Symfony autowiring automatically infers and injects dependencies based on type-hints, so you do not need to manually declare every service in services.yaml." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes and caches them to a directory between requests for performance."}

{"answer": "yes", "explanation": "In the Symfony dev environment, the DI container is cached and only rebuilt when tracked configuration or source files change, not on every request."}

```json ⏎ { ⏎   "answer": "APP_ENV", ⏎   "explanation": "In modern Symfony applications, the APP_ENV environment variable selects the active environment (dev/prod), though the legacy Symfony Environment Variable (SEV) allows using the ENV variable as well." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "Symfony routing with attribute-based controllers (controllers as services) invokes any public or private method specified via routing attributes, since Symfony uses reflection and the method_exists/ReflectionMethod checks with isAccessible rather than requiring public visibility."}

{"answer": "false", "explanation": "Event subscribers and listeners receive events based on the priority they are assigned via the `getSubscribedEvents` method and the priority parameter, not based on the fact that they are subscribers."}

```json ⏎ {"answer": "yes", "explanation": "Symfony 6.0 removed the legacy 'guard' authentication system and fully adopted the modern authenticator-based system built on AuthenticatorInterface."} ⏎ ```

{"answer": "#IsGranted", "explanation": "The #IsGranted attribute (from Symfony\\Component\\Security\\Http\\Attribute\\IsGranted) is used on controller methods to check roles/permissions and returns 403 when the check fails."}

```json ⏎ {"answer": "false", "explanation": "The correct method is isGranted(), not isGranted(), and the example uses 'EDIT' which should typically be a string like 'EDIT_POST'; the statement incorrectly names the method."} ⏎ ```

{"answer": "yes", "explanation": "Symfony 7 dropped support for Doctrine annotations, requiring validation constraints to be declared via PHP attributes, named arguments, or XML/YAML instead."}

{"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default using the 'csrf_token_generator' service and the 'csrf_token_id' option, so the form validates the token automatically on submission unless explicitly disabled."}

{"answer": "yes", "explanation": "Symfony form validation always runs server-side on submission regardless of any client-side HTML5 validation passing."}

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

```json ⏎ {"answer": "no", "explanation": "Symfony never stores the user's password in the session (or anywhere), as passwords are only verified by hashing and comparison, never stored in plaintext."} ⏎ ```

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

{"answer": "false", "explanation": "It is backwards: .env.local is typically git-ignored for secrets, while committed files contain only safe defaults like .env.example."}

{"answer": "php bin/console debug:container", "explanation": "The `debug:container` command displays all registered services and their aliases in the Symfony dependency injection container."}

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "In Symfony, the service container parameters are compiled at build time and the container is frozen after compilation, so calling setParameter() at runtime throws a RuntimeException." ⏎ } ⏎ ```

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "By default, Symfony services are private (public: false) unless explicitly configured as public to prevent unintended direct container access." ⏎ } ⏎ ```

{"answer": "false", "explanation": "Bundles do not require a config file in config/packages to function, as many bundles provide sensible defaults and only need configuration when custom settings are required."}

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

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

{"answer": "false", "explanation": "A single message in Symfony Messenger can have multiple handlers, as Symfony invokes all registered handlers for a given message type."}

{"answer": "no", "explanation": "In Symfony Messenger, the sync transport delivers the message synchronously in the same request/process rather than enqueueing it for a separate worker."}

{"answer": "php artisan queue:work", "explanation": "The queue:work command starts a queue worker that processes jobs (including Messenger messages dispatched to a queue) from the configured queue connection."}

{"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy (including attempts, delay, and multiplier) is configured per-transport in the messenger.dsn or retry configuration."}

{"answer": "no", "explanation": "Messenger by default serializes messages using PHP's native serialize() function, not JSON."}

{"answer": "no", "explanation": "The Symfony Scheduler is designed for running scheduled tasks/cron-like code and does not dispatch messages through the Messenger component, which is a separate system for asynchronous message handling."}

{"answer": "DoctrineMessengerTransport", "explanation": "The DoctrineMessengerTransport is the built-in Symfony Messenger transport that persists messages in database tables via Doctrine ORM."}

{"answer": "yes", "explanation": "The Messenger pipeline (Symfony's MessageBus/Messenger) supports custom middleware that can be added before or after the built-in ones via the `middleware` configuration using `from`/`to` constraints."}

{"answer": "yes", "explanation": "Symfony follows a predictable release schedule where major releases occur every two years and minor releases are published every six months in May and November."}

{"answer": "8.2", "explanation": "Symfony 8 requires PHP 8.2 or higher as its minimum version."}

{"answer": "no", "explanation": "Symfony 7.0 dropped support for PHPDoc annotations in favor of attributes, requiring the use of attributes for validation and route configuration."}

{"answer": "no", "explanation": "AssetMapper manages CSS/JS without node or webpack via its own asset import system, while importmap.php is used by the separate ImportMap functionality."}

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release, not a regular release, offering 5 years of bug fixes and 2 additional years of security fixes."}

{"answer": "false", "explanation": "A new Symfony major version removes all deprecations introduced in previous versions, which is why the deprecation detector tool warns that tests may fail when upgrading."}

```json ⏎ {"answer": "yes", "explanation": "Every Symfony major release is documented with a UPGRADE guide listing the breaking changes and migrations required between versions."} ⏎ ```

```json ⏎ {"answer": "symfony/importmap", "explanation": "The Symfony ImportMap component manages frontend assets (JavaScript, CSS) via browser ES modules, eliminating the need for Node or Webpack."} ⏎ ```

{"answer": "false", "explanation": "Symfony 8.x does not exist yet, as Symfony version 7 is the current major version as of late 2024/2025 and the 8.x line has not been released by 2026-11-07."}

{"answer": "true", "explanation": "Symfony follows its usual six-month release cycle, with Symfony 8.2 scheduled for May 2026 and subsequent 8.3 in November 2026."}

{"answer": "8.2", "explanation": "Symfony follows a predictable release schedule where major versions are released annually in November, so 8.2 follows 8.1."}

{"answer": "no", "explanation": "Symfony 8.2 is a maintenance/lts release focused on bug fixes and minor improvements, not a major rewrite requiring application changes."}

```json ⏎ {"answer": "false", "explanation": "While PHP's backward compatibility promise applies within a major version line, upgrading from 8.1 to 8.2 can still require code changes because deprecated features emit warnings and deprecated functions are removed in later minor versions."} ⏎ ```

{"answer": "8.5", "explanation": "The last minor version of the Symfony 8.x branch before Symfony 9.0 is 8.5, as minor versions are released every four months with odd numbers marking LTS releases and 8.5 being the final planned 8.x release."}

{"answer": "no", "explanation": "Symfony 8.0 is scheduled for November 2027 and will require PHP 8.4, not 8.5 (which will not exist until November 2028), and there is no \"Symfony 8.2\" release."}

```json ⏎ { ⏎     "answer": "yes", ⏎     "explanation": "Per Symfony's deprecation policy, deprecations introduced in the 8.x branch are guaranteed to remain (not be removed) until Symfony 9.0." ⏎ } ⏎ ```

{"answer": "no", "explanation": "Twig's {{ }} syntax is used for outputting variables and expressions, not for executing arbitrary PHP code, which violates Twig's security and design principles."}

{"answer": "yes", "explanation": "Twig automatically escapes printed variables using HTML escaping by default unless a different escaper is configured."}

{"answer": "yes", "explanation": "The Twig |e filter (or its alias |escape) escapes a string to make it safe for output in an HTML context by default, using the HTML escaping strategy."}

```json ⏎ {"answer": "number_format", "explanation": "The number_format filter from twig/intl-extra formats a number according to a locale using the NumberFormatter class."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "The |raw filter in Twig disables auto-escaping for the value by marking it as safe HTML."} ⏎ ```

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "In Twig, the {{ }} output tags print expression values while the {% %} action tags execute logic such as conditions, loops, and set statements." ⏎ } ⏎ ```

```json ⏎ { ⏎   "answer": "false", ⏎   "explanation": "You can declare template-local variables in Twig using the set tag, even though values conventionally come from the controller." ⏎ } ⏎ ```

{"answer": "dump", "explanation": "The dump() function in Twig dumps the debug structure of a variable such as an array or object."}

{"answer": "yes", "explanation": "Bootstrap is indeed a CSS and JavaScript framework for building UI components, not a single-page application (SPA) framework like React, Angular, or Vue."}

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

{"answer": "no", "explanation": "Bootstrap's grid system is built on CSS Flexbox (since Bootstrap 4) and splits each row into 12 columns, not 16."}

```json ⏎ {"answer": "yes", "explanation": "Bootstrap 5's five named breakpoints are indeed sm, md, lg, xl, and xxl."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Bootstrap's spacing utility classes (.mt-3, .px-2, etc.) are generated from the $spacer variable through the spacing map and scale function, so the numeric value selects a multiple of $spacer."} ⏎ ```

```json ⏎ { ⏎   "answer": "data-bs-toggle", ⏎   "explanation": "In Bootstrap 5, the data-bs-toggle attribute enables interactive components like dropdowns, modals, and tooltips on an element." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "Bootstrap 5 dropped jQuery as a dependency and its components (like modals, carousels, and dropdowns) now use plain vanilla JavaScript."}

```json ⏎ { ⏎ "answer": "false", ⏎ "explanation": "Bootstrap's dark mode uses the [data-bs-theme=\"dark\"] attribute rather than a .dark class on the root element." ⏎ } ⏎ ```

{"answer": "no", "explanation": "Doctrine ORM does not create tables automatically at runtime; tables must be created explicitly using the 'orm:schema-tool:create' command or a migration system."}

{"answer": "persist", "explanation": "The persist() method marks a new object as managed and defers the actual INSERT SQL execution until flush() is called."}

```json ⏎ {"answer": "no", "explanation": "In Doctrine ORM 3, EntityManager::merge() was removed (deprecated in ORM 2.14), so the method no longer exists."} ⏎ ```

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is designed to work with entities and their properties at the object level rather than database tables and columns."}

{"answer": "null","explanation": "When using Doctrine Repository find() with an id that doesn't exist, it returns null."}

{"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 (persistent) entity, Doctrine's Unit of Work performs change detection during flush() and automatically persists property changes without needing an explicit persist() call."}

{"answer": "no", "explanation": "In Doctrine ORM, remove() only schedules the entity for deletion; the actual SQL DELETE is executed during flush(), not immediately."}

```json ⏎ {"answer": "no", "explanation": "PostgreSQL's MVCC design specifically allows readers and writers to proceed concurrently without blocking each other, since readers see a snapshot of the data from before uncommitted writes."} ⏎ ```

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command (or EXPLAIN ANALYZE in some databases) displays a query's execution plan without actually running it."}

```json ⏎ {"answer": "false", "explanation": "SERIAL and GENERATED COLUMN ... AS IDENTITY are distinct mechanisms: SERIAL is a PostgreSQL pseudo-type that implicitly creates a sequence and default nextval(), while GENERATED ... AS IDENTITY is a standard SQL feature with more detailed control over identity column behavior."} ⏎ ```

{"answer": "false", "explanation": "By default, PostgreSQL treats NULLs as distinct in a UNIQUE constraint, so it allows multiple rows containing NULL values, not just one."}

{"answer": "STRING_AGG", "explanation": "STRING_AGG is the PostgreSQL aggregate function that concatenates string values with a specified separator using the WITHIN GROUP clause."}

```json ⏎ { ⏎  "answer": "no", ⏎  "explanation": "Plain VACUUM in PostgreSQL reclaims space occupied by dead tuples but returns it to the table (for reuse) rather than giving it back to the operating system, unlike VACUUM FULL which does return the space to the OS." ⏎ } ⏎ ```

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

{"answer": "no", "explanation": "The READ COMMITTED isolation level protects against dirty reads but not against non-repeatable reads, which require the higher REPEATABLE READ isolation level."}

{"answer": "yes", "explanation": "PostgreSQL automatically commits each SQL statement in its own implicit transaction when autocommit mode is on, unless a transaction block is explicitly started with BEGIN."}

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

{"answer": "yes", "explanation": "Indexes speed up data retrieval for UPDATE and DELETE statements that filter on indexed columns via WHERE clauses, not just SELECT, by allowing the database to quickly locate matching rows instead of performing a full table scan."}

{"answer": "yes", "explanation": "SAVEPOINT allows you to create a marker within a transaction so you can ROLL BACK to that point, undoing only the statements executed after the SAVEPOINT while keeping the rest of the transaction intact."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports both the plan and the real execution time, whereas plain EXPLAIN only shows the plan without executing."}

```json ⏎ { ⏎   "answer": "pgvector", ⏎   "explanation": "pgvector is the PostgreSQL extension that adds vector data types and indexing (HNSW, IVF) for embedding-based similarity search." ⏎ } ⏎ ```

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

{"answer": "no", "explanation": "SERIALIZABLE in PostgreSQL is implemented using MVCC timestamps and predicate locks via the Serializable Snapshot Isolation (SSI) protocol, not by locking the rows a transaction reads."}

{"answer": "yes", "explanation": "HTTP 201 Created indicates that the request has successfully led to the creation of a new resource."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates a successful request with no body to return, commonly used after DELETE operations."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "DELETE is defined as idempotent in the HTTP specification, so repeated DELETE requests for the same resource produce the same server state (the resource is removed) and the same response semantics regardless of how many times it is sent." ⏎ } ⏎ ```

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

{"answer": "yes", "explanation": "HTTP status 429 Too Many Requests is the standard response code indicating a user has sent too many requests in a given period (rate limiting)."}

{"answer": "no", "explanation": "It is the opposite: 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 entity body sent in an HTTP request or response."}

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

{"answer": "no", "explanation": "Using == to compare password hashes is vulnerable to timing attacks and can reveal information; a constant-time comparison function like hash_equals() should be used instead."}

{"answer": "yes", "explanation": "A CSRF token is generated by the server and stored in the session, then verified server-side on unsafe requests to ensure the request originated from a legitimate client."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header allows site administrators to control which resources the browser is allowed to load for a given page, thereby enabling the CSP policy."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol, and an access token grants access to resources rather than reliably identifying who the user is (which is better served by OpenID Connect.)"}

{"answer": "no", "explanation": "This is false because XSS should be prevented by output encoding/escaping (context-dependent) when rendering data in HTML, not by validating input before storage, since the same stored data may need to be used safely in multiple different contexts."}

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

{"answer": "yes", "explanation": "Refresh tokens are designed to outlive access tokens and enable obtaining new access tokens without requiring the user to re-authenticate."}

{"answer": "no", "explanation": "A salt does not need to be secret—its purpose is to prevent precomputed rainbow table attacks and ensure identical passwords produce different hashes, and it is commonly stored alongside the hash."}

{"answer": "no", "explanation": "PHPUnit only recognizes and runs test methods in classes that extend the PHPUnit\\Framework\\TestCase class."}

{"answer": "no", "explanation": "setUp() runs before each individual test method, not once before all tests."}

{"answer": "false", "explanation": "A data provider can supply multiple sets of arguments, allowing a single test method to run multiple times with different data."}

{"answer": "expectException", "explanation": "The expectException method in PHPUnit is used to declare an expectation that a specific exception 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 predefined data without verifying calls."}

{"answer": "yes", "explanation": "In PHPUnit 10+, the #[DataProvider] attribute is the recommended way to specify data providers, while the older @dataProvider annotation was deprecated."}

{"answer": "no", "explanation": "PHPUnit supports test dependencies through the @depends annotation (or #[Depends] attribute in v9+), which allows one test to depend on the result of another, including passing return values as arguments."}

{"answer": "--order-by=random", "explanation": "The --order-by=random option instructs PHPUnit to execute test methods in a random order rather than sequentially."}

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

{"answer": "9", "explanation": "In PHP 7+, the exponentiation operator ** follows mathematical convention where -3 ** 2 evaluates to -9, but wait, let me reconsider: the code actually outputs -9 because unary minus has lower precedence than **... actually PHP ** binds tighter, so -3 ** 2 = -(3**2) = -9."}

```json ⏎ {"answer": "true", "explanation": "PHP converts both strings to numbers in the comparison, treating '1e1' as 10 and '10' as 10, so they are equal."} ⏎ ```

{"answer": "other", "explanation": "The switch compares 'a' to case 0 using loose comparison, where 'a' becomes 0 but the case value 0 cast to string is '', so 'a' !== '' and no case matches, executing the default block."}

```json ⏎ {"answer": "abc", "explanation": "strtr() with an array uses the largest matching key first, and since no key matches at position 0 (neither 'a' nor 'ab' matches), it returns the string unchanged."} ⏎ ```

{"answer": "[hello]", "explanation": "When the negative offset (-10) exceeds the string length (5), substr returns the entire string 'hello', so the output is '[hello]'."}

{"answer": "k,n,m","explanation": "The union operator (+) keeps $a's keys for 'k', keeps $a's 'n', and adds $b's 'm' since $b's 'k' is already present, yielding keys k, n, m."}

```json ⏎ { ⏎     "answer": "yzx", ⏎     "explanation": "usort sorts the array by the third column ascending ([1,2,2]), reordering the rows so their second columns become y, z, x." ⏎ } ⏎ ```

{"answer": "4", "explanation": "The named arguments are matched to the parameters regardless of order, so f($a=5, $b=1) returns 5-1=4."}

```json ⏎ {"answer": "3", "explanation": "The arrow function captures $p by value at creation time, binding to the P instance, so calling $f() after $p is set to null still invokes g() on the captured object instance, returning 3."} ⏎ ```

{"answer": "B", "explanation": "The who() method returns static::class, which uses late static binding to return the class that was actually instantiated (B), not the class where the method is defined (A)."}

{"answer": "10", "explanation": "The property uses PHP 8.4's new property hooks feature, where the setter multiplies the assigned value (5) by 2, resulting in 10."}

```json ⏎ {"answer": "BA", "explanation": "The aliasing configuration resolves the conflict by making f() come from TB (returning 'B') and exposing TA's f() as g() (returning 'A')."} ⏎ ```

```json ⏎ {"answer": "0", "explanation": "In PHP, static properties in traits are copied into each using class, so CX::$n and CY::$n are independent properties, meaning CY::$n retains its default value of 0."} ⏎ ```

{"answer": "2", "explanation": "The finally block's return statement overrides the try block's return value, so f() returns 2."}

{"answer": "second", "explanation": "The inner try throws RuntimeException, but the finally block throws LogicException which overrides it and is caught by the catch block, echoing 'second'."}

{"answer": "N\\Foo|Baz", "explanation": "The use statement aliased Foo to Baz only within the namespace, so Baz::class resolves to N\\Foo, while the fully-qualified \\Baz refers to a nonexistent class Baz in the global namespace."}

{"answer": "nones","explanation":"In the current namespace, class_exists('Foo') looks for Ns\\Foo (not found), while class_exists('Ns\\Foo') finds the defined class, yielding 'no' + 'yes'."}

```json ⏎ {"answer": "1,2,99", "explanation": "After the foreach with by-reference assignment, $v remains as a reference to $a[2], so $v = 99 modifies $a[2] to 99."} ⏎ ```

{"answer": "1", "explanation": "Static variables in PHP are per-class (per scope), so A::$n and B::$n are separate, meaning B's call doesn't affect A's counter, which is 1 on the final $a->inc() call."}

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

```json ⏎ {"answer": "1,2,ok","explanation": "The `yield from` forwards the values from inner() (1 and 2), captures the returned value 'ok', then yields it, so the array is [1, 2, 'ok'] which implodes to '1,2,ok'."} ⏎ ```

```json ⏎ { ⏎   "answer": "noyes", ⏎   "explanation": "The first comparison uses the same cost (4) as the hash was created with, so no rehash is needed, while the second uses a higher cost (5), requiring a rehash." ⏎ } ⏎ ```

```json ⏎ {"answer": "strict-in", "explanation": "E_ALL has always included the E_STRICT flag (bit value 2048) since PHP 5.2, so E_ALL & 2048 always evaluates to a non-zero value, making the === comparison to 0 false and outputting 'strict-in'."} ⏎ ```

```json ⏎ {"answer": "mapped", "explanation": "Symfony's HeaderUtils maps underscored HTTP header names (HTTP_X_TOKEN) to their canonical form (X-Token) when retrieving via $r->headers->get()."} ⏎ ```

{"answer": "ABC", "explanation": "Listeners are executed in ascending priority order, so the listeners with priorities 10, 0 (default), and 5 run in that order, appending B, A, and C respectively."}

```json ⏎ {"answer": "same", "explanation": "Doctrine's EntityManager uses a first-level identity cache (unit of work) so repeated finds of the same identifier return the same managed entity instance within a single request."} ⏎ ```

```json ⏎ {"answer": "0", "explanation": "The entity is persisted then removed before flush, so the Unit of Work schedules a deletion and no row is ever inserted into the database."} ⏎ ```

```json ⏎ {"answer": "1", "explanation": "count(x) counts only non-NULL values of x, and since only one row has x=1 while the other is NULL, it returns 1."} ⏎ ```

```json ⏎ {"answer": "10,30,60", "explanation": "The window sum is 10, 30, 60 for the three rows, and string_agg concatenates them in ascending id order."} ⏎ ```

```json ⏎ {"answer": "M1M2", "explanation": "The MessageBus wraps middlewares in a stack, so the first middleware (M1) runs first, echoes 'M1', then calls the next middleware (M2), which echoes 'M2' before the stack's terminator (the bus itself) handles the message."} ⏎ ```

```json ⏎ {"answer": "11", "explanation": "Both handler descriptors (h1 and h2) are registered for the Ping message, so the HandleMessageMiddleware invokes them in order, running h1 (n += 1, making n = 1) and then h2 (n += 10, making n = 11)."} ⏎ ```

```json ⏎ {"answer": "1", "explanation": "The first INSERT adds the value 1, and the second INSERT conflicts with the unique index so ON CONFLICT DO NOTHING discards it, leaving one row."} ⏎ ```

{"answer": "2", "explanation": "Deferred unique constraints are only checked at COMMIT, not at INSERT, so both INSERTs succeed and the row is only validated when the transaction implicitly commits after the final query."}

```json ⏎ { ⏎   "answer": "4", ⏎   "explanation": "The `--filter test_sum` matches both test_sum (2 data providers, wait actually 3) and test_sum_abs (3 data providers), totaling 6 tests since the filter matches any test name containing test_sum, including test_sum_abs." ⏎ } ⏎ ```

{"answer": "2, 1", "explanation": "The data provider returns two test cases ([1] and [-1]), so 2 tests run, and test_x asserts $x > 0 which fails for -1, so 1 fails."}

```json ⏎ {"answer": "POST", "explanation": "The `-d` option (equivalent to `--data`) sends data in the request body, which forces curl to use the HTTP POST method."} ⏎ ```

{"answer": "GET", "explanation": "The -G option in curl sends data passed with -d via the URL query string using the GET method instead of the default POST method."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, when a client authentication fails or the client_id is non-existent, the authorization server returns an 'invalid_client' error value."}

{"answer": "fragment", "explanation": "With response_type=token (implicit flow), the access token and other parameters are returned in the URL fragment (the part after the #), which is not sent to the server for security reasons."}

{"answer": "0", "explanation": "The default filter returns false because false is not considered null, and false * 3 evaluates to 0 in Twig's arithmetic coercion."}

```json ⏎ { ⏎   "answer": "Twig\\Error\\SyntaxError", ⏎   "explanation": "The concatenation operator ~ has lower precedence than +, so Twig parses 'a' ~ (1 + 2) and tries to concatenate the result (a string) with the integer 'a' using the ~ operator, which Twig cannot cast to a string, throwing a SyntaxError." ⏎ } ⏎ ```

{"answer": "0", "explanation": "The string '' (empty string) violates the NotBlank constraint, so the validator should return a ConstraintViolationList with one violation, meaning count() should output 1, not 0."}

```json ⏎ { ⏎   "answer": "Symfony\\Component\\Form\\FormException", ⏎   "explanation": "Calling isValid() before submitting data throws a FormException because the form must be submitted/processed first." ⏎ } ⏎ ```

```json ⏎ {"answer": "same", "explanation": "Singletons are cached in the container, so multiple get() calls return the same object instance."} ⏎ ```

```json ⏎ { ⏎   "answer": "hi Bob!", ⏎   "explanation": "The ContainerBuilder recursively resolves nested parameter placeholders, so 'message' (%greeting!%) expands to 'hi %name%!' which then expands to 'hi Bob!'" ⏎ } ⏎ ```

{"answer": "960px", "explanation": "In Bootstrap 5.3, the .container has a max-width of 960px at the lg breakpoint (≥992px), as the container widths are 540px, 720px, 960px, and 1140px for sm, md, lg, and xl respectively."}

{"answer": "text-primary", "explanation": "The text-primary class comes later in the source order and overrides text-danger, which is why it wins in Bootstrap 5.3's cascade."}

```json ⏎ { ⏎   "answer": "2", ⏎   "explanation": "OrderService (Domain) depends on PlaceOrder from Application and Db from Infrastructure, both of which violate the rules since Domain may only depend on Domain." ⏎ } ⏎ ```

{"answer": "2", "explanation": "BillingService (Domain) imports PlaceOrder (Application) via constructor type-hint, violating Application→Domain, and Db (Infrastructure) directly, violating Infrastructure→Domain; the Logger type is a fully-qualified string literal that Deptrac does not count as an internal dependency."}

```json ⏎ {"answer": "10,15","explanation": "The `add()` method returns a new Money object with the summed amount (15) while the original object `$a` remains unchanged at 10 due to immutable readonly properties."} ⏎ ```

```json ⏎ {"answer": 0, "explanation": "The add('a') puts one item in $items, then remove('a') triggers the DomainException because count===1, the exception is caught, and $items remains unchanged with 0 items (the unset never runs)."} ⏎ ```

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

{"answer": "yesno", "explanation": "newLazyGhost creates an uninitialized ghost object so isUninitializedLazyObject() returns 'yes' initially, and accessing $o->v triggers the initialization callback which marks it initialized, so the second check returns 'no'."}

```json ⏎ { ⏎     "answer": "no", ⏎     "explanation": "The AbstractGuardAuthenticator class was removed in Symfony 6.1, so it does not exist in Symfony 8.1." ⏎ } ⏎ ```

```json ⏎ {"answer": "nonyes", "explanation": "In Symfony 8.x the legacy AnnotationClassLoader was removed (annotations routing support was dropped), so class_exists returns false, while AttributeClassLoader still exists for attribute-based routing."} ⏎ ```