PHP Developer interview questions

PHP provides scalar, compound, and special value types.

• Scalar types include bool, int, float, and string.
• Compound types include array, object, callable, and iterable.
• null represents the absence of a value, while resource represents a handle to an external resource.

Dynamic typing means a variable's type is determined from its current value at runtime rather than fixed at declaration.

• The same variable can hold values of different types during its lifetime.
• PHP may coerce compatible scalar values in some operations and function calls.
• Parameter, property, and return declarations still let developers enforce explicit contracts.

It disables scalar argument coercion for function calls made from that file.

• Without strict mode, PHP may coerce a compatible scalar argument such as a numeric string to an int.
• With strict mode, an incompatible scalar argument normally causes a TypeError instead.
• It does not turn PHP into a statically typed language or validate untyped variables automatically.

The == operator compares values after PHP type juggling, while === requires both value and type to match.

• A loose comparison can treat values of different types as equal after coercion.
• An identical comparison performs no type conversion.
• Strict comparison is usually safer when input may contain strings, numbers, booleans, or null.

A cast converts a value to a requested type with syntax such as (int), (float), (string), (bool), or (array).

• Casting a numeric string to int or float produces its numeric value according to PHP conversion rules.
• Boolean casting follows PHP truthiness rules rather than parsing words such as false semantically.
• A cast does not validate whether the original value was meaningful for the application.

PHP supports type declarations on function parameters, return values, and class properties.

• Declarations document the values that an API accepts, returns, or stores.
• Violations produce TypeError rather than silently storing an incompatible value.
• Built-in types, class names, interfaces, and compound types can participate in declarations.

A nullable type permits null, while a union type permits a value from several listed types.

• ?User is shorthand for User|null.
• A declaration such as int|float accepts either listed numeric type.
• Union members should describe a meaningful contract rather than replace clear data modeling with many alternatives.

PHP treats false, 0, 0.0, empty strings, the string '0', an empty array, and null as falsey.

• Other non-empty strings are truthy even when their text reads 'false'.
• Empty objects are truthy.
• Explicit comparison is clearer when zero, an empty string, and null have different meanings.

The ?? operator returns its left operand when that value is set and not null, otherwise it returns the right operand.

• It is commonly used for optional array keys or request values.
• Its check follows isset semantics, so a present key containing null uses the fallback.
• It avoids the undefined-key notice that direct access could produce before a fallback.

Single-quoted strings perform minimal escaping, while double-quoted strings interpret variables and more escape sequences.

• A double-quoted string can interpolate a variable such as $name.
• The dot operator concatenates strings regardless of quote style.
• Braces make interpolation boundaries clear when a variable touches surrounding text.

strlen returns the number of bytes in a string, while mb_strlen counts characters for a specified multibyte encoding.

• ASCII characters usually occupy one byte, so both results often match for ASCII text.
• UTF-8 characters may occupy several bytes, making strlen unsuitable for a character count.
• mb_strlen requires the mbstring extension and should use the application's known encoding.

str_contains and strpos search within strings, while substr extracts a portion by offset and length.

• str_contains returns a boolean and is convenient for a simple containment check.
• strpos returns an integer position or false, so position zero must be compared with !== false.
• Multibyte text may require the corresponding mb_ functions for character-based offsets.

An indexed array uses integer keys, while an associative array uses string keys to name values.

• PHP implements both forms with the same ordered array type.
• Integer and string keys can coexist in one array, although a consistent shape is easier to maintain.
• Indexed arrays commonly represent lists, while associative arrays commonly represent records or lookup tables.

PHP uses square-bracket syntax for array access and assignment, with [] appending to the next integer key.

• $items['name'] reads or writes a named key.
• $items[] = $value appends without manually calculating an index.
• unset($items[$key]) removes a key without automatically reindexing the remaining integer keys.

isset checks that a key exists and its value is not null, while array_key_exists checks only whether the key exists.

• A key with a null value makes isset return false.
• The same key makes array_key_exists return true.
• The choice depends on whether null means missing or is a valid stored value.

They transform, select, and aggregate array values through callback functions.

• array_map produces values by applying a callback to input elements.
• array_filter keeps elements that satisfy a callback and preserves their original keys.
• array_reduce combines all elements into one accumulated result.

sort orders values and reindexes keys, asort orders values while preserving key associations, and ksort orders by keys.

• sort is suitable for a simple indexed list where original keys do not matter.
• asort keeps each value paired with its existing key.
• The functions mutate the supplied array and return a success boolean rather than the sorted array.

They all combine arrays, but their behavior for duplicate and numeric keys differs.

• array_merge overwrites duplicate string keys with later values and reindexes numeric keys.
• Array unpacking with ... is convenient for building a new array and generally follows merge-like numeric-key behavior.
• The + operator preserves values from the left array when the same key exists on both sides.

Array destructuring assigns array elements to separate variables with [] or list syntax.

• Positional destructuring reads values by integer position.
• Associative destructuring can name the keys being extracted.
• Missing elements may produce warnings, so the expected array shape should be known.

foreach iterates an array by value by default and can bind the loop variable by reference with &.

• By-value iteration does not directly modify scalar elements through the loop variable.
• By-reference iteration can update the original elements.
• The reference variable should be unset after the loop so later assignments do not modify the last element accidentally.