PHP Developer interview questions

For user-defined function calls, scalar argument coercion is controlled by the file containing the call, not the file declaring the function.

• A call made from a file with declare(strict_types=1) normally raises TypeError when a scalar argument has the wrong type.
• The declaration applies per file and does not make included files or callers strict automatically.
• An int is still accepted for a float parameter in strict mode and is converted to float.

These compound types express alternatives, simultaneous contracts, and combinations of both.

• A union such as A|B accepts a value matching at least one listed type.
• An intersection such as A&B requires an object that is an instance of every listed class or interface type.
• A DNF type such as (A&B)|C is a union whose intersection members are parenthesized.
• PHP rejects redundant or impossible combinations at compile time when it can determine them without autoloading.

Nullability controls accepted values, while a default controls whether the caller may omit an argument.

• ?User and User|null both explicitly allow a User instance or null.
• A nullable parameter without a default is still required, while a non-null default does not make its type nullable.
• Declaring User $user = null relies on implicit nullability and is deprecated as of PHP 8.4, so the type should state null explicitly.

mixed accepts any value, void promises no meaningful return value, and never promises that execution cannot return normally.

• mixed includes null and therefore cannot be combined redundantly with another union member.
• A void function may use a bare return but cannot return an expression.
• A never function must always throw, terminate execution, or continue indefinitely.

An overriding method may narrow its return type covariantly and widen its parameter types contravariantly.

• A narrower return still satisfies callers that expect the parent's broader result contract.
• A wider parameter accepts every input valid for the parent and possibly more.
• Reversing either direction would break substitutability and is rejected as an incompatible signature.

A typed property without a default starts uninitialized, which is a separate state from holding null.

• Reading it before assignment raises an Error even when its declared type is nullable.
• A constructor or another valid write must initialize it before normal reads.
• unset() returns a typed property to the uninitialized state, and isset() then reports false.

Readonly prevents reassignment of initialized property slots, but it does not make an entire object graph deeply immutable.

• A readonly property must have a declared type and can be initialized only according to PHP's readonly visibility rules.
• A readonly class makes all instance properties readonly and disallows dynamic properties.
• An object stored in a readonly property can still mutate its own internal state.
• Array elements in a readonly property cannot be changed because that operation modifies the property value itself.

A unit enum represents named cases only, while a backed enum gives every case a unique int or string value.

• All enums implement UnitEnum and expose cases(), while backed enums also implement BackedEnum.
• A backed case exposes value, and from() or tryFrom() converts a scalar to a case with throwing or nullable failure behavior.
• Enums can define methods and implement interfaces, but they cannot declare properties.

Attributes attach structured metadata to declarations, while reflection lets application code discover and interpret that metadata.

• An attribute is a class marked with #[Attribute] and can restrict its allowed targets and repeatability.
• ReflectionAttribute exposes the name and raw arguments without constructing the attribute object.
• Calling newInstance() validates and invokes the attribute constructor, so metadata has no effect unless some consumer reads it.

Use an interface for a capability contract across unrelated types and an abstract class when related subclasses also need shared implementation or state.

• A class can implement several interfaces but can extend only one class.
• An abstract class may provide constructors, properties, concrete methods, and abstract method requirements.
• Depending on interfaces at public boundaries usually preserves more freedom to replace implementations.

Multiple focused interfaces let a class expose only the capabilities that each client actually needs.

• PHP permits one class to implement any number of compatible interfaces despite single class inheritance.
• Interface segregation avoids forcing implementations to provide irrelevant methods or throw unsupported-operation errors.
• Small contracts produce narrower dependencies and simpler test doubles at call sites.

A trait supplies reusable implementation to a class, whereas an interface defines behavior that consumers may rely on.

• Using a trait copies its methods and properties into the consuming class's composition model.
• A trait does not create a standalone runtime type that a parameter can require.
• A class can implement an interface without sharing code, or use a trait while still declaring the interface explicitly.

PHP requires explicit adaptation when imported traits provide methods with the same name.

• The insteadof operator selects one trait's implementation over another conflicting implementation.
• The as operator creates an alias or changes the imported method's visibility without renaming the original method.
• Aliasing the losing method preserves access to both implementations when each has a distinct purpose.

Static members belong to class-level state and behavior rather than to one object instance.

• A static method has no $this and should receive any instance-specific collaborators explicitly.
• A mutable static property can be observed across calls and objects, creating hidden coupling and test isolation problems.
• Inheritance, redeclaration, and late static binding affect which class-level member is addressed, so shared state should not be assumed casually.

self:: resolves relative to the class where the method is declared, while static:: uses the class named by the runtime call through late static binding.

• A method inherited by a child still treats self as the declaring class.
• static:: and new static() allow an inherited implementation to honor the called subclass.
• Use self when the implementation must be fixed to its declaring class and static when deliberate subclass customization is part of the contract.

final closes selected extension points when an implementation or invariant must not be changed by subclasses.

• A final class cannot be extended, while a final method cannot be overridden in an otherwise extensible class.
• A final class constant prevents descendants from redefining that constant.
• final does not make object state immutable and should express a design boundary rather than block extension without reason.

PHP invokes __get and __set when code reads or writes an inaccessible or nonexistent instance property.

• __get receives the property name and returns the exposed value, while __set receives both the name and assigned value.
• Accessing the same unresolved property inside its hook can recurse or produce confusing behavior.
• Magic properties hide the real object shape from type checks, refactoring tools, and readers unless the boundary is kept narrow.

They intercept calls to inaccessible or nonexistent methods in instance and static contexts respectively.

• Each hook receives the requested method name and an array of supplied arguments.
• They can implement proxies or constrained dynamic APIs, but they also risk hiding misspellings until runtime.
• Explicit methods or generated adapters are preferable when the supported operation set is stable and should be visible to tools.

These hooks define existence checks and removal behavior for inaccessible or nonexistent instance properties.

• isset() and empty() can invoke __isset, whose boolean result should match the object's virtual-property semantics.
• unset() invokes __unset, which can remove or clear the corresponding internal value.
• Their behavior should stay consistent with __get and __set, especially when null has a distinct domain meaning.

__invoke makes an object callable, while __toString defines its conversion in a string context.

• An invokable object can retain dependencies or configuration while being passed wherever a callable is accepted.
• __toString must return a string and PHP automatically treats a class declaring it as Stringable.
• String conversion should be predictable and side-effect free because logging, interpolation, and concatenation may trigger it implicitly.