Карта знаний PHP — huihui-ai:pi-100k, run-78 · think: low

{"answer":"no","explanation":"Double-quoted strings support variable interpolation and escape sequences, while single-quoted strings treat content literally, so they are not processed identically."}

{"answer": "yes", "explanation": "The null coalescing operator (??) uses isset() semantics internally, so it does not raise warnings or notices for undefined variables."}

{"answer": "ab", "explanation": "echo in PHP accepts multiple comma-separated arguments and outputs them sequentially without any separator."}

{"answer": "no", "explanation": "While print does return the value 1, it is a language construct (not a function) and cannot be used inside an expression, e.g. $x = 2 * print('hello') is a syntax error."}

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

{"answer": "yes", "explanation": "In PHP's operator precedence, + and - bind more tightly than the concatenation operator ., so e.g. '1' + 2 . 3 is parsed as ('1'+2) . 3."}

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

{"answer": 3, "explanation": "The concatenation operator '.' has higher precedence than '+', so it parses as ('sum: ' . 2) + 3, which becomes 'sum: 2' + 3, and in PHP 8 the non-numeric string converts to 0, yielding 0 + 3 = 3."}

{"answer": "no", "explanation": "Strict comparison (===) requires arrays to have the same key/value pairs in the same order, while loose comparison (==) ignores order."}

{"answer":"no","explanation":"0 == false uses loose comparison (==), and it actually returns true, since false is cast to 0 and 0 == 0 is true."}

{"answer":"no","explanation":"In PHP 8, comparing a non-numeric string with an integer casts the integer to a string, so 'abc' == 0 becomes 'abc' == '0', which is false."}

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

{"answer": 42, "explanation": "PHP casts a string to int by reading leading numeric characters until it hits a non-numeric one, so '42abc' becomes 42."}

{"answer": 10, "explanation": "PHP type juggling converts the numeric string '5' to the integer 5, so 5 + 5 = 10."}

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

{"answer": "yes", "explanation": "Due to IEEE 754 floating-point precision, 0.1 + 0.2 yields 0.30000000000000004, which is not strictly equal to 0.3."}

{"answer":"no","explanation":"strrev() operates on individual bytes, so multi-byte UTF-8 characters get their bytes reversed independently, producing invalid UTF-8 output."}

{"answer": "yes", "explanation": "str_contains('Hello world', 'world') returns true because 'world' is a substring of 'Hello world'."}

{"answer": "no", "explanation": "str_pad() can pad on the right, left, or both sides using the $pad_type parameter (STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH)."}

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

```json ⏎ {"answer": 6, "explanation": "In UTF-8, 'é' takes 2 bytes while the other four characters each take 1 byte, so strlen() returns 6."} ⏎ ```

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

{"answer": "no", "explanation": "ucfirst() returns a new string with the first character uppercased; it does not modify the original string in place."}

{"answer": "yes", "explanation": "Heredoc supports variable interpolation like double-quoted strings, while nowdoc (with quoted delimiter) treats content like single-quoted strings, so variables are not interpolated."}

{"answer": "no", "explanation": "sort() re-indexes the array with numeric keys starting from 0; to preserve key associations, use asort() instead."}

{"answer": "yes", "explanation": "In PHP, numeric string keys like '5' are automatically cast to integers when used as array keys."}

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

{"answer": "yes", "explanation": "When array_filter() is called without a callback, it removes all elements with falsy values (0, '0', '', null, false, [])."}

{"answer": "no", "explanation": "The $preserve_keys parameter of array_slice() defaults to false, meaning keys are reindexed by default."}

{"answer": "[20, 30]", "explanation": "array_slice with offset 1 and length 2 returns the elements at indices 1 and 2, which are 20 and 30."}

{"answer": 2, "explanation": "The + operator performs array union where left keys take precedence, resulting in ['a' => 1, 'b' => 2] which has 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1's array spread syntax [...$a, ...$b] supports both integer and string keys, unlike the older function-call spread which required sequential integer keys."}

{"answer": "no", "explanation": "Named arguments can be combined with argument unpacking in a single call, as long as the named arguments appear before the ...$args unpacking (e.g., foo(a: 1, ...$args))."}

{"answer": "no", "explanation": "In PHP, closures do not automatically capture outer-scope variables; they must be explicitly imported with the 'use' keyword."}

{"answer": 3, "explanation": "func_num_args() returns the number of arguments actually passed to the function (3), not the number of declared parameters (1)."}

{"answer": "no", "explanation": "Arrow functions (fn) in PHP must have a single expression as their body; they cannot contain multiple expressions in curly braces."}

```json ⏎ {"answer": "no", "explanation": "Arrow functions (fn) capture outer variables by value at call time (lazy by-value), not by reference; the PHP RFC and docs explicitly state 'by value' capture, just deferred to invocation time."} ⏎ ```

{"answer": "yes", "explanation": "A static closure in PHP explicitly does not bind $this from the enclosing scope, unlike a regular closure which does."}

{"answer": 5, "explanation": "The closure captures $x by value (no & used), so it retains the original value of 5 even after $x is reassigned to 7."}

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

{"answer": "yes", "explanation": "Constructor property promotion was introduced in PHP 8.0, allowing visibility modifiers and types on constructor parameters to automatically create class properties."}

{"answer": "final", "explanation": "In PHP, the 'final' keyword applied to a method prevents it from being overridden in subclasses."}

{"answer": "yes", "explanation": "In PHP, the 'final' keyword prevents a method from being overridden in any subclass."}

{"answer": "no", "explanation": "Private properties are only accessible within the class that defines them, not in subclasses; protected or public visibility would be needed for subclass access."}

```json ⏎ {"answer": "class@anonymous", "explanation": "PHP anonymous classes have names in the format 'class@anonymous\\x00/path:line', so the part before the NUL byte is 'class@anonymous'."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, private methods are not part of the inheritance contract; a child class can declare a method with the same name and any visibility, as it is treated as a completely independent method."}

{"answer": "no", "explanation": "__get() is called for both inaccessible (private/protected) and non-existent properties, not only non-existent ones."}

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP 8.1+ throws a TypeError, which extends Error (not Exception)."}

{"answer": "yes", "explanation": "PHP interfaces can declare constants, which are always public and read-only."}

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

{"answer": "yes", "explanation": "PHP interfaces can declare static methods, and the implementing class must provide the implementation."}

{"answer": "no", "explanation": "The instanceof operator in PHP checks both class inheritance and interface implementation; it returns true if the object is an instance of the class or implements the interface."}

{"answer": "no", "explanation": "Interface methods in PHP are always abstract and cannot have a body/implementation, unlike trait methods which can provide a concrete implementation."}

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared as public or protected, but not private."}

{"answer": 3, "explanation": "Foo::cases() returns an array containing all cases of the enum, which are A, B, and C — three elements."}

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

{"answer": "yes", "explanation": "In PHP 7+, the Throwable interface is implemented by both Exception and Error, making it their common ancestor."}

{"answer": "no", "explanation": "TypeError extends Error, not Exception; both inherit from Throwable, but they are sibling classes, so catch(Exception) does not catch TypeError."}

{"answer": "no", "explanation": "The @ operator only suppresses errors (warnings, notices, etc.) but does not catch or suppress exceptions, which are a separate mechanism in PHP."}

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError, which is a subclass of ArithmeticError, when the divisor is zero."}

{"answer": "no", "explanation": "The finally block executes regardless of whether an exception was thrown or caught — it always runs."}

{"answer": "no", "explanation": "An exception thrown in a finally block will replace any exception being propagated from the try/catch block, so it does affect the overall result."}

{"answer": "yes", "explanation": "In PHP, casting any object to bool always returns true."}

{"answer": "yes", "explanation": "Shutdown functions registered with register_shutdown_function() are called when the script terminates, including when exit or die is invoked."}

{"answer": "no", "explanation": "The 'use' statement only creates a local alias for a fully qualified class name and does not trigger autoloading or load the file; the file is loaded only when the class is actually referenced."}

{"answer": "function", "explanation": "In PHP, to import a function you use 'use function Namespace\\functionName;', while 'const' is used for importing constants."}

{"answer": "src/Controller/Api/UserController.php", "explanation": "PSR-4 strips the App\\ prefix, converts remaining backslashes to directory separators, and appends .php to the base path src/."}

{"answer": "yes", "explanation": "Composer's vendor/autoload.php ultimately calls spl_autoload_register() to register the Composer autoloader class with PHP's SPL autoload mechanism."}

{"answer": "yes", "explanation": "__NAMESPACE__ is a magic constant in PHP that returns the name of the current namespace (or an empty string for the global namespace)."}

{"answer": "no", "explanation": "An unqualified class name in 'new' is resolved relative to the current namespace, not the global root; a leading backslash is needed for global root resolution."}

{"answer": "yes", "explanation": "PSR-4 maps the remaining namespace segments (Model\\User) to subdirectories and appends the class name with .php, resulting in src/Model/User.php."}

{"answer": "yes", "explanation": "In PHP, a `use` statement is a compile-time directive that can be placed inside a function body, in which case it is scoped to that function only."}

{"answer": "yes", "explanation": "In PHP, arrays are value types; assigning an array to another variable creates a copy, not a reference."}

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

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

{"answer": "no", "explanation": "unset($GLOBALS['x']) directly removes the variable from the global scope, so it is gone for all scopes, not just the current function."}

{"answer": 6, "explanation": "The parameter is passed by reference, so the increment inside the function directly modifies $n from 5 to 6."}

```json ⏎ {"answer": "no", "explanation": "A foreach by value iterates over a snapshot (copy-on-write) of the array, so additions, removals, or value modifications made inside the loop body are not reflected in the current iteration pass."} ⏎ ```

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

{"answer": "no", "explanation": "In PHP, boolean keys are cast to integers: true becomes 1 and false becomes 0."}

{"answer": "yes", "explanation": "In PHP, a generator can use return with a value, and that value is accessible via Generator::getReturn() after the generator is exhausted."}

```json ⏎ {"answer": "no", "explanation": "Once a generator is fully consumed (closed), calling rewind() on it throws a RuntimeException; it can only be rewound before first iteration begins."} ⏎ ```

{"answer": "no", "explanation": "PHP has the yield keyword (since PHP 7.0) but no 'yield from' construct; 'yield from' is a Python 3.3+ feature."}

{"answer": "Generator", "explanation": "Calling a generator function returns a Generator object, and get_class() on it returns the string 'Generator'."}

{"answer": 3, "explanation": "The generator yields 1, 2, 3, which iterator_to_array converts to an array with 3 elements, and count returns 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (Last In, First Out) stack, not a FIFO queue; SplQueue is the one that implements FIFO."}

{"answer": "yes", "explanation": "ArrayIterator is a built-in PHP class that implements the Iterator interface, allowing you to wrap an array and iterate over it with methods like current(), next(), key(), valid(), and rewind()."}

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

{"answer": "yes", "explanation": "password_hash() automatically generates and embeds a salt in the returned hash, so no separate salt needs to be provided."}

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT is bcrypt (PASSWORD_BCRYPT), not md5."}

{"answer": "yes", "explanation": "password_verify returns true when the plaintext matches the hash, and here 'secret' matches its own hash."}

{"answer": "no", "explanation": "strip_tags() removes HTML/PHP tags from a string but does not protect against SQL injection; prepared statements or parameterized queries are needed for that."}

{"answer": "yes", "explanation": "session_regenerate_id() creates a new session ID while keeping session data intact, which is the standard defense against session fixation attacks after a user's privilege level changes (e.g., upon login)."}

{"answer": "php_sapi_name()", "explanation": "php_sapi_name() is the built-in function that returns the current SAPI module name, such as 'cli', 'fpm-fcgi', or 'apache2handler'."}

{"answer": "yes", "explanation": "session_destroy() only destroys the server-side session data; the session cookie in the browser must be removed separately by unsetting $_COOKIE and calling setcookie() with a past expiration."}

{"answer": "no", "explanation": "You must call session_start() before accessing $_SESSION; without it, the array is empty and not populated with server-side session data."}

{"answer": "8.4", "explanation": "The array_find() function was introduced in PHP 8.4 as a higher-order function for finding the first element matching a callback."}

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

{"answer": "yes", "explanation": "Asymmetric visibility, allowing different read and write access levels (e.g. public private(set)), was introduced in PHP 8.4."}

{"answer": "8.4", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.4 to signal that a function's return value should not be discarded by the caller."}

{"answer": 8.4, "explanation": "The pipe operator (|>) was introduced in PHP 8.4 as part of an accepted RFC."}

{"answer": 8.4, "explanation": "The 'clone with' syntax, which allows passing arguments to __clone(), was accepted in the RFC for PHP 8.4."}

{"answer": "8.4", "explanation": "array_first() and array_last() were introduced in PHP 8.4 as part of new array helper functions."}

```json ⏎ {"answer": 8.4, "explanation": "The RFC for partial function/closure application was adopted for PHP 8.4."} ⏎ ```

{"answer": "8.4", "explanation": "The clamp_v2 RFC was implemented in PHP 8.4."}

```json ⏎ {"answer": "no", "explanation": "As of late 2026, no RFC titled 'Context Managers v2' has been adopted into PHP; the feature remains in proposal or draft stage."} ⏎ ```

{"answer": "yes", "explanation": "The RFC for Bound-Erased Generic Types in PHP was voted down (declined) in 2026."}

{"answer": "no", "explanation": "As of 2026, while ZTS builds are available and there have been discussions and proposals, an RFC to make ZTS the default build has not yet been accepted in PHP."}

```json ⏎ {"answer": "yes", "explanation": "PHP has no built-in generics or parameterized types as of PHP 8.5; only PHPDoc @template annotations exist for static analysis, not enforced by the language itself."} ⏎ ```

{"answer": "yes", "explanation": "PHP follows a ~6-month release cadence in November; 8.5 was released in November 2025, and 8.6 is scheduled for November 2026, so as of 2026-11-07, 8.5 is the latest stable version."}

{"answer": "yes", "explanation": "PHP 6 was a planned major version that was never released; PHP 7.0 was released directly after PHP 5.6."}

{"answer": "no", "explanation": "The RFC to add a native #[\\Deprecated] attribute to PHP core was rejected (not adopted), failing to reach the required 2/3 majority in the vote."}

{"answer": "yes", "explanation": "The dependency rule of clean/onion architecture states that dependencies must point inwards toward the domain core, and inner layers have no knowledge of outer layers."}

{"answer": "yes", "explanation": "In DDD, domain entities should be framework-agnostic, relying only on the PHP language and standard library, not on Doctrine or Symfony."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation (interface) layer, not the business-logic layer; they simply call use cases that reside in the application layer."}

{"answer": "Entities", "explanation": "In onion architecture, the Entity layer (core business rules and domain entities) sits at the very center, with all other layers depending inward on it."}

{"answer": "yes", "explanation": "Deptrac and similar layer-dependency analyzers can be configured to define allowed dependencies between layers and automatically fail when a forbidden cross-layer call is detected."}

```json ⏎ {"answer": "no", "explanation": "A use case should be decoupled from input/output details; it should accept simple data (e.g., a command object) and depend on abstractions (e.g., a repository interface) rather than concrete types like an HTTP request or EntityManager."} ⏎ ```

{"answer": "Repository", "explanation": "The Repository pattern provides a collection-like interface for aggregates/entities while abstracting the underlying storage mechanism."}

{"answer": "yes", "explanation": "In clean architecture, the database is an infrastructure detail in the outermost layer; domain and use cases depend on abstractions (interfaces), so swapping the database only requires changes in the data-access/infrastructure layer."}

{"answer": "no", "explanation": "An aggregate in DDD is a cluster of domain objects (entities and value objects) treated as a single consistency boundary, which can span multiple database tables and is a conceptual model rather than a database table."}

{"answer": "yes", "explanation": "By definition in Domain-Driven Design, a Value Object is immutable and its equality is determined by the equality of its field values, not by object identity."}

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

{"answer": "yes", "explanation": "In DDD, a Repository is defined per Aggregate Root, not per individual entity; entities within an aggregate are accessed through the root."}

{"answer": "yes", "explanation": "Ubiquitous Language, a core DDD concept from Eric Evans, is indeed a shared language between developers and domain experts used consistently in code, documentation, and conversation."}

{"answer": "bounded context", "explanation": "In Domain-Driven Design, a bounded context is the boundary within which a model and its language are consistent, while the same terms can have different meanings in other bounded contexts."}

{"answer": "no", "explanation": "DDD recommends a rich domain model where business logic is encapsulated within entities and value objects, not placed in external service classes (anemic model is considered an anti-pattern in DDD)."}

{"answer": "yes", "explanation": "In DDD, each bounded context has its own model, so the same real-world concept (e.g., 'Customer') can be represented by different classes in different contexts."}

{"answer": "yes", "explanation": "Symfony's DI container instantiates services lazily by default, meaning a service object is only created when it is first requested or injected into another service."}

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

{"answer": "no", "explanation": "Autowiring automatically resolves dependencies based on type hints, and combined with autoconfiguration, services can be registered without manual declaration in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into PHP classes (extending Twig\\Template) and caches the resulting PHP files to avoid recompilation on subsequent requests."}

{"answer": "yes", "explanation": "In the dev environment, Symfony caches the compiled container in var/cache/dev/ and only rebuilds it when tracked files (config, services, etc.) have changed."}

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

{"answer":"no","explanation":"Symfony controller methods must be public; private or protected methods will cause an error when the router tries to invoke them."}

{"answer": "no", "explanation": "Event dispatch order is determined solely by the numeric priority value assigned to each listener or subscriber, not by whether it is a subscriber or a listener."}

```json ⏎ {"answer": "yes", "explanation": "The Guard system was deprecated in Symfony 5.3 and removed in 6.0, replaced by the new authenticator system based on AuthenticatorInterface."} ⏎ ```

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute in Symfony's Security Bundle checks a role or permission on a controller method and throws AccessDeniedException (403) if the user is not granted."}

{"answer": "yes", "explanation": "Voters are Symfony's recommended mechanism for object-level security, used via isGranted('EDIT', $post) to check if a user can perform an action on a specific object."}

{"answer": "no", "explanation": "In Symfony 7, doctrine annotations (docblock-style) are still supported for validation constraints; they are deprecated in favor of PHP attributes but not removed."}

{"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default; a CSRF token is automatically added to the form and validated on submission unless explicitly disabled."}

{"answer": "yes", "explanation": "Symfony form validation is performed server-side by the Form Validator and is independent of HTML5 client-side validation; both must pass for the form to be considered valid."}

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

{"answer": "no", "explanation": "Symfony stores the user's identifier (e.g., ID or username) in the session, not the password; the password is only used to verify against the hash during login."}

{"answer": "yes", "explanation": "Symfony's recommended convention is to place one YAML/XML/PHP config file per bundle or topic in the config/packages/ directory."}

{"answer": "yes", "explanation": "This is a standard pattern in PHP frameworks like Laravel, where .env holds committed dev defaults and .env.local holds uncommitted secrets."}

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

{"answer": "no", "explanation": "The container is frozen after compilation, so calling setParameter() from a controller throws a LogicException."}

{"answer": "no", "explanation": "Since Symfony 4.1, services are private (public: false) by default; they must be explicitly marked as public to be fetched from the container."}

{"answer": "no", "explanation": "Many bundles work with their default configuration and do not require a config file in config/packages/."}

{"answer": "yes", "explanation": "In Symfony, environment variables are referenced in configuration files like services.yaml using the %env(VAR_NAME)% syntax."}

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable in Symfony controls whether debug mode is enabled, which affects the profiler, Twig debug output, and other development features."}

{"answer": "no", "explanation": "Symfony Messenger allows multiple handlers for the same message; all registered handlers will be invoked in priority order."}

{"answer": "no", "explanation": "The sync transport does not queue the message; it dispatches and processes it immediately in the same process, unlike async transports which hand it off to a worker."}

{"answer": "messenger:consume", "explanation": "The Symfony Messenger command `messenger:consume` starts a worker process that consumes messages from the specified transports/queues."}

```json ⏎ {"answer": "yes", "explanation": "In Symfony Messenger, retry_strategy (max_retries, multiplier, delay) is configured within each individual transport's configuration block."} ⏎ ```

{"answer": "yes", "explanation": "By default, Symfony Messenger uses the Serializer component with JSON format to serialize messages."}

{"answer": "yes", "explanation": "Symfony Scheduler defines recurring tasks and uses Messenger to dispatch messages to their handlers at scheduled intervals."}

{"answer": "doctrine", "explanation": "The doctrine transport in Symfony Messenger stores messages in database tables via Doctrine."}

{"answer": "yes", "explanation": "Laravel's Messenger pipeline allows custom middleware via the job's $middleware property, which are combined with built-in middleware in the pipeline."}

{"answer": "no", "explanation": "Symfony releases a new version every 6 months (May and November), and a major version (X.0) comes approximately every year, not every two years."}

```json ⏎ {"answer": "8.4", "explanation": "Symfony 8 requires a minimum PHP version of 8.4, following the pattern of each major version bumping the minimum PHP requirement."} ⏎ ```

{"answer": "no", "explanation": "Symfony 7.0 removed support for docblock annotations; PHP attributes are the only supported way to define metadata like routes and validation constraints."}

```json ⏎ {"answer": "yes", "explanation": "Symfony's AssetMapper (alongside the ImportMap component) manages CSS/JS assets without requiring Node.js or Webpack, using importmap.php to declare and resolve JavaScript imports."} ⏎ ```

{"answer": "no", "explanation": "Symfony 6.4 is a Long-Term Support (LTS) release, as all even-numbered minor versions are LTS."}

```json ⏎ {"answer": "no", "explanation": "The entire purpose of Symfony's deprecation cycle is that deprecations introduced in one major version are removed in the next major version (e.g., deprecations from 6.x are removed in 7.0)."} ⏎ ```

{"answer": "yes", "explanation": "Symfony provides UPGRADE-X.Y.md files in its repository for each major release, documenting all breaking changes and upgrades."}

{"answer": "AssetMapper", "explanation": "Symfony's AssetMapper component manages JavaScript and CSS assets without requiring Node.js or Webpack, and works alongside the ImportMap component."}

```json ⏎ {"answer": "no", "explanation": "Symfony's November releases have historically occurred around November 29–30, so by November 7, 2026, Symfony 8.2 would likely not yet be released."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Following the six-month cycle from Symfony 7.0 (May 2024), November 2026 would be Symfony 8.1, not 8.2."} ⏎ ```

{"answer": 8.2, "explanation": "Symfony follows minor version increments, so the version after 8.1 is 8.2."}

{"answer": "no", "explanation": "Symfony 8.2 would be a minor release (x.y), not a major one (x.0); minor releases add features without breaking changes, and even major releases don't require a full rewrite."}

{"answer": "yes", "explanation": "PHP preserves backward compatibility within minor versions (e.g., 8.1 to 8.2); breaking changes are only allowed in major version bumps."}

{"answer": "8.1", "explanation": "Symfony 8.0 was released in November 2025, followed by 8.1 in May 2026, which is the last minor release of the 8.x branch before Symfony 9.0 in November 2026."}

{"answer": "no", "explanation": "Symfony 8.x is expected to require PHP 8.4 as its minimum version, not PHP 8.5."}

{"answer": "yes", "explanation": "Per Symfony's deprecation policy, deprecations introduced in a given major version are removed in the next major version, so 8.x deprecations are removed in 9.0, not before it."}

{"answer":"no","explanation":"Twig's {{ }} allows a limited expression language (variables, filters, method calls on objects, etc.), but you cannot call arbitrary PHP functions or code directly."}

{"answer": "yes", "explanation": "Twig enables auto-escaping by default (with the 'html' strategy) to protect against XSS attacks."}

{"answer": "yes", "explanation": "The Twig |e (escape) filter defaults to the 'html' escape strategy, which escapes a string for safe output in an HTML context."}

{"answer": "number_format", "explanation": "The number_format filter in twig/intl-extra formats a number according to a given locale."}

{"answer": "yes", "explanation": "In Laravel Blade, the |raw filter disables auto-escaping, making {{ $var | raw }} equivalent to {!! $var !!}."}

{"answer": "yes", "explanation": "In Twig, {{ }} is for outputting expressions and {% %} is for control structures like if, for, set, etc."}

{"answer": "no", "explanation": "Twig allows you to declare variables inside a template using the {% set %} tag, so values are not limited to what comes from the controller."}

{"answer": "dump", "explanation": "The dump() function in Twig (from the Debug extension) outputs a formatted debug representation of a variable such as an array or object."}

{"answer": "yes", "explanation": "Bootstrap is a front-end CSS/JS library providing ready-made UI components (modals, navbars, etc.), not an SPA framework like React or Angular."}

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

{"answer": "no", "explanation": "Bootstrap's grid is built on flexbox (not floats) and splits a row into 12 columns, not 16."}

{"answer": "yes", "explanation": "Bootstrap 5 defines exactly five breakpoints: sm (576px), md (768px), lg (992px), xl (1200px), and xxl (1400px)."}

{"answer": "yes", "explanation": "In Bootstrap, spacing utilities like .mt-3 or .px-2 multiply the $spacer variable by the given number (e.g., .mt-3 = $spacer * 3)."}

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the data-bs-toggle attribute is used to enable interactive components such as dropdowns, tooltips, popovers, and collapse on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 removed its jQuery dependency and all components (modals, dropdowns, tooltips, etc.) are powered by plain vanilla JavaScript."}

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

{"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; schema management is done separately via migrations or SchemaTool."}

{"answer": "persist", "explanation": "EntityManager::persist() marks an entity as managed in the unit of work without executing SQL until flush() is called."}

```json ⏎ {"answer": "no", "explanation": "In Doctrine ORM 3, EntityManager::merge() was removed entirely; it no longer exists in the interface."} ⏎ ```

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is object-oriented and operates on entities and their mapped fields, not on database tables and columns."}

{"answer": "null", "explanation": "In Doctrine, the repository find() method returns null when no entity with the given identifier exists."}

{"answer": "yes", "explanation": "DoctrineBundle registers a listener on the kernel.response event that automatically calls flush() on all entity managers at the end of each request (controlled by the auto_commit option, which defaults to true)."}

{"answer": "yes", "explanation": "The Unit of Work tracks managed entities and detects property changes at flush() time via change tracking, so no explicit persist() is needed."}

{"answer": "no", "explanation": "In Doctrine ORM, remove() only marks the entity for deletion in the UnitOfWork; the actual SQL DELETE is executed upon flush()."}

{"answer": "no", "explanation": "MVCC is specifically designed so that readers do NOT block writers and writers do NOT block readers; each transaction sees its own version of the data."}

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

{"answer": "no", "explanation": "While both use sequences to generate values, SERIAL creates an independent sequence object with a default constraint, whereas GENERATED ... AS IDENTITY creates a tightly coupled identity column with different lifecycle and behavioral rules (e.g., dropping the column also drops the sequence, and identity columns have stricter modification rules)."}

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

{"answer": "string_agg", "explanation": "PostgreSQL's string_agg(expression, separator) is the aggregate function that concatenates strings with a specified separator."}

{"answer": "no", "explanation": "Plain VACUUM marks dead tuples as reusable space within the table but does not return it to the operating system; only VACUUM FULL rewrites the table and returns space to the OS."}

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

{"answer":"no","explanation":"READ COMMITTED only protects against dirty reads; non-repeatable reads can still occur because another transaction can modify and commit a row between two reads within the same transaction."}

{"answer": "yes", "explanation": "PostgreSQL operates in autocommit mode by default, where each single SQL statement is implicitly wrapped in its own transaction and committed upon successful completion."}

{"answer": "COMMIT", "explanation": "The COMMIT SQL command permanently saves all changes made during the current transaction."}

{"answer": "yes", "explanation": "Indexes are used by the query optimizer for any statement that locates rows, including UPDATE and DELETE with a WHERE clause on an indexed column, avoiding a full table scan."}

{"answer": "yes", "explanation": "SAVEPOINT allows you to roll back to a specific point within a transaction, undoing only the statements executed after that savepoint."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports actual execution statistics, while plain EXPLAIN shows the plan without executing."}

{"answer": "pgvector", "explanation": "pgvector is a PostgreSQL extension that adds vector types and indexes for similarity search on embeddings."}

{"answer": "yes", "explanation": "A partial index only includes rows that satisfy the WHERE condition, making it smaller and more efficient than a full index."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which tracks read/write dependencies and detects cycles, rather than by locking rows that are read."}

{"answer": "yes", "explanation": "HTTP 201 'Created' indicates that the request was successful and a new resource has been created as a result."}

{"answer": 204, "explanation": "HTTP 204 No Content indicates the server successfully processed the request but is returning an empty response body, commonly used after DELETE operations."}

```json ⏎ {"answer": "yes", "explanation": "RFC 9110 (HTTP Semantics) Section 9.2.2 explicitly states 'The DELETE method is idempotent,' meaning repeating the request does not produce additional state changes beyond the initial deletion."} ⏎ ```

{"answer":"no","explanation":"The Access-Control-Allow-Origin header is sent by the server, not the client; the client sends the Origin header."}

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests is defined in RFC 6585 and is used to indicate that a client has sent too many requests in a given time frame (rate limiting)."}

{"answer": "no", "explanation": "It's the opposite: 4xx codes indicate client errors, and 5xx codes indicate server-side errors."}

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

{"answer": "yes", "explanation": "RFC 5789 explicitly states that the PATCH method is not idempotent, whereas PUT is idempotent by definition in RFC 7231."}

{"answer": "no", "explanation": "Using == (or even ===) is vulnerable to timing attacks; you should use hash_equals() which performs a constant-time comparison."}

{"answer": "yes", "explanation": "A CSRF token is generated by the server, bound to the user's session, and validated server-side on state-changing requests (POST, PUT, DELETE) to confirm the request originated from a legitimate user."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is used to define a set of rules that control what sources the browser is allowed to load resources from, mitigating XSS and data injection attacks."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization protocol, not an authentication protocol; the access token grants permission to access resources rather than identifying who the user is."}

{"answer": "no", "explanation": "XSS is primarily prevented by output encoding/escaping at the point of rendering, not by input validation before storing to the database."}

{"answer": "authorization_code", "explanation": "In the OAuth 2.0 authorization code flow, the authorization server redirects back to the client's redirect_uri with an authorization_code parameter, which the client then exchanges for an access token at the token endpoint."}

{"answer": "yes", "explanation": "A refresh token has a longer validity period than an access token and is specifically designed to obtain a new access token without requiring the user to log in again."}

{"answer": "no", "explanation": "A salt does not need to be secret; it is typically stored alongside the hash. Its purpose is to ensure identical passwords produce different hashes, defeating rainbow table attacks."}

{"answer": "no", "explanation": "PHPUnit requires test classes to extend PHPUnit\\Framework\\TestCase in order to be recognized and executed by the test runner."}

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

{"answer": "no", "explanation": "A data provider allows a test to run multiple times, each with a different set of arguments."}

{"answer": "expectException", "explanation": "PHPUnit's expectException() method is used to declare that an exception of a given class is expected to be thrown during the test."}

{"answer": "no", "explanation": "It's the opposite: a stub returns canned data, while a mock verifies that methods were called with expected arguments and constraints."}

{"answer": "yes", "explanation": "In PHPUnit 10+, the #[DataProvider] PHP 8 attribute is the recommended replacement for the @dataProvider doc-comment annotation, which is considered deprecated."}

{"answer": "no", "explanation": "PHPUnit provides the @depends annotation (or #[Depends] attribute) that explicitly allows one test to depend on the result of another, passing it as a parameter."}

{"answer": "--order-by=random", "explanation": "The --order-by=random option in PHPUnit causes test methods to be executed in a randomized order."}

{"answer": "3-3", "explanation": "intdiv(7,2) gives 3 and intdiv(-7,2) gives -3 (truncation toward zero), concatenated as a string yields '3-3'."}

{"answer": -9, "explanation": "In PHP, the exponentiation operator ** has higher precedence than unary minus, so -3 ** 2 is evaluated as -(3 ** 2) = -9."}

{"answer": "true", "explanation": "Both '1e1' and '10' are numeric strings, so PHP compares them numerically; 1e1 equals 10, making them equal."}

```json ⏎ {"answer": "other", "explanation": "In PHP, 'a' == 0 is false (non-numeric string vs 0), so the switch falls through to the default case."} ⏎ ```

{"answer":"2c","explanation":"strtr with string keys matches the longest key first, so 'ab' is replaced with '2' before 'a' is considered, yielding '2c'."}

{"answer":"[]","explanation":"substr('hello', -10) starts counting 10 positions from the end, which is before the string begins, so it returns an empty string."}

{"answer": "k,n,m", "explanation": "The union operator (+) preserves left operand keys for duplicates, so keys are k, n, m."}

```json ⏎ {"answer": "yxz", "explanation": "After sorting by the third element ascending (1,2,2), the column at index 1 becomes ['y','x','z'], which implodes to 'yxz'."} ⏎ ```

{"answer": 4, "explanation": "The spread operator with an associative array uses the keys as parameter names, so 'a' => 5 and 'b' => 1, giving $a - $b = 5 - 1 = 4."}

```json ⏎ {"answer": 3, "explanation": "A first-class callable captures the object instance by reference, so even after $p is set to null, $f still holds a valid reference to the object and g() returns $this->v which is 3."} ⏎ ```

{"answer": "B", "explanation": "static::class uses late static binding, so it returns the class of the actual object (B), not the class where the method is defined (A)."}

```json ⏎ {"answer": 10, "explanation": "The setter hook multiplies the assigned value by 2, so assigning 5 stores 10 in the property."} ⏎ ```

{"answer": "BA", "explanation": "TB::f insteadof TA makes f() return 'B', and TA::f as g creates an alias g() that returns 'A', so the concatenation is 'BA'."}

{"answer": 0, "explanation": "Traits are copied into each class, so CX and CY each have their own independent static property; setting CX::$n does not affect CY::$n, which remains 0."}

{"answer": 2, "explanation": "In PHP, a return statement in a finally block overrides the return value from the try block."}

{"answer": "second", "explanation": "When a new exception is thrown in a finally block, it replaces the currently propagating exception, so the LogicException('second') is what gets caught."}

{"answer": "App\\Foo|Baz", "explanation": "Baz is an alias for App\\Foo via the use statement, so Baz::class resolves to 'App\\Foo', while \\Baz::class refers to the global class Baz, resolving to 'Baz'."}

{"answer": "noyes", "explanation": "class_exists('Foo') looks for a global class 'Foo' which doesn't exist (the class is 'Ns\\Foo'), while class_exists('Ns\\Foo') finds it, so the output is 'no' . 'yes' = 'noyes'."}

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

{"answer": 3, "explanation": "The static variable $n is shared between A and B since B inherits the same method without overriding it, so it increments 1→2→3 across the three calls."}

```json ⏎ {"answer": "", "explanation": "The generator is suspended at 'yield 1' after the first send (which is ignored on a new generator), so it never reaches the return statement and getReturn() returns null, which echo outputs as an empty string."} ⏎ ```

{"answer":"1,2,ok","explanation":"yield from delegates to inner() which yields 1 and 2, then its return value 'ok' is captured by $r and yielded by outer(), so iterator_to_array collects [1, 2, 'ok']."}

{"answer": "noyes", "explanation": "The first call returns false (cost matches at 4), echoing 'no'; the second returns true (cost differs at 5), echoing 'yes'."}

```json ⏎ {"answer": "strict-out", "explanation": "In PHP 8.5, E_STRICT (2048) is no longer included in E_ALL, so E_ALL & 2048 equals 0, making the condition true."} ⏎ ```

```json ⏎ {"answer": "mapped", "explanation": "Symfony's HeaderBag strips the HTTP_ prefix and converts underscores to dashes, so HTTP_X_TOKEN becomes X-TOKEN, and since HeaderBag::get() is case-insensitive, get('X-Token') returns 'abc'."} ⏎ ```

{"answer": "BCA", "explanation": "Symfony's EventDispatcher calls listeners in descending order of priority (higher priority first): B(10), C(5), A(0)."}

```json ⏎ {"answer": "same", "explanation": "Doctrine's identity map ensures that find() returns the already-managed instance, so both $a and $b are the same object as $u."} ⏎ ```

```json ⏎ {"answer": 0, "explanation": "Persisting then removing a new entity before flush causes Doctrine's UnitOfWork to cancel the insertion entirely, so no row is ever written to the table."} ⏎ ```

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

```json ⏎ {"answer": "10,30,60", "explanation": "The window function computes a running sum of x (10, 30, 60), then string_agg concatenates them in id order."} ⏎ ```

{"answer": "M1M2", "explanation": "The MessageBus executes middleware in order: M1 echoes 'M1' and delegates to M2, which echoes 'M2' and delegates to the final handler, so the output is 'M1M2'."}

{"answer": 11, "explanation": "HandleMessageMiddleware calls all matching handlers in order; the first increments $n by 1 and the second by 10, giving a total of 11."}

{"answer": 1, "explanation": "The first INSERT succeeds, the second hits the unique index conflict and is skipped by DO NOTHING, leaving one row."}

{"answer": 2, "explanation": "The UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, so the duplicate value (1) is not rejected until COMMIT; both rows exist, so count(*) returns 2."}

{"answer": 6, "explanation": "The --filter test_sum matches both test_sum (3 data sets) and test_sum_abs (3 data sets) since the filter is a substring match, totaling 6 tests."}

```json ⏎ {"answer": "2, 1", "explanation": "The data provider yields two datasets ([1] and [-1]); the first passes (1>0) and the second fails (-1>0 is false)."} ⏎ ```

{"answer": "POST", "explanation": "The -d flag in curl sends data in the request body, which automatically triggers the POST method."}

{"answer": "GET", "explanation": "The -G flag forces curl to use the GET method, appending the -d data as a query string to the URL."}

{"answer": "invalid_client", "explanation": "RFC 6749 Section 5.2 defines 'invalid_client' as the error returned when the client authentication fails, such as when the provided client_id does not exist."}

{"answer": "fragment", "explanation": "In the OAuth 2.0 implicit grant flow (response_type=token), the access token is passed in the URI fragment (after the # symbol) of the redirect_uri."}

{"answer": 0, "explanation": "The default filter only triggers on null/undefined, not on false, so false|default(2) remains false, and false*3 equals 0."}

```json ⏎ {"answer": "a3", "explanation": "In Twig, the + operator has higher precedence than ~, so it evaluates as 'a' ~ (1+2) = 'a' ~ 3 = 'a3', with no exception thrown."} ⏎ ```

{"answer": 0, "explanation": "NotBlank on an array only checks if the array is non-empty; [''] has one element, so the constraint passes and there are 0 violations."}

{"answer": "valid", "explanation": "A TextType field without a NotBlank constraint considers an empty string as valid, so isValid() returns true."}

```json ⏎ {"answer": "same", "explanation": "Symfony DI container services are singleton by default, so get('a') returns the same instance both times."} ⏎ ```

{"answer": "hi Bob!", "explanation": "Symfony's parameter bag resolves nested references recursively during compile: %greeting%! → 'hi %name%!' → 'hi Bob!'"}

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

{"answer": "text-danger", "explanation": "In Bootstrap 5.3, text-danger is defined after text-primary in the CSS, so with equal specificity it wins the cascade."}

```json ⏎ {"answer": 2, "explanation": "The class is in the Domain layer, which is only allowed to depend on Domain; it depends on both Application and Infrastructure, giving 2 violations."} ⏎ ```

```json ⏎ {"answer": 3, "explanation": "Domain can only depend on Domain, but this class depends on Application (PlaceOrder) and Infrastructure (Db, Logger), giving 3 violations."} ⏎ ```

{"answer": "10,15", "explanation": "$a->amount is 10, and $c is a new Money object with amount 10+5=15, so the echo outputs '10,15'."}

{"answer": 1, "explanation": "The remove() method throws before unset() is reached, so 'a' remains in the items array, making count() return 1."}

{"answer": "hi", "explanation": "The code creates an instance of class C and calls the hi() method, which returns the string 'hi', so echo outputs 'hi'."}

{"answer": "yesno", "explanation": "The lazy ghost is initially uninitialized (yes), but accessing $o->v triggers the init callback, after which it is no longer uninitialized (no)."}

```json ⏎ {"answer": "no", "explanation": "The Guard authentication system (including AbstractGuardAuthenticator) was removed in Symfony 6.0, so it does not exist in 8.1."} ⏎ ```

```json ⏎ {"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 8.0 (deprecated in 7.0), while AttributeClassLoader is the current replacement, so class_exists returns false for the former and true for the latter."} ⏎ ```