PHP Coding

array_map applies a callback to every value and returns an array of the same size, keeping the keys when one array is passed. array_filter keeps the values whose callback result is truthy and preserves the original keys, so it leaves gaps. array_reduce folds the whole array into one accumulated value.

array_slice is non-destructive: it leaves the source untouched and returns the extracted portion. array_splice takes the array by reference, removes the selected range from it in place, optionally substitutes a replacement, and returns the elements it removed. Splice always renumbers the integer keys.

Return an anonymous function that captures $in by reference via use (&$in). By-reference capture lets the closure mutate the same variable across calls, so the running total persists. Without &, each call would start from the original $in because the value is copied at definition time.

It receives its collaborators already built. Instead of calling new PdoUserRepository() inside itself, the class declares a UserRepository parameter and is handed an instance by whoever constructs it. The dependency becomes visible in the signature, and a test can pass a fake in place of the real thing without touching the class.

array_merge renumbers integer keys, so entries are appended rather than overwritten, and for a duplicate string key the later argument wins. The + operator never renumbers and never overwrites: for any key already present in the left operand, the left value is kept. So + favours the first array, array_merge the last.

reset and end were built for the internal array pointer: they move it and return the first or last value, never the key. array_key_first and array_key_last return the key itself, leave the pointer where it was, and hand back null on an empty array instead of false, so no side effect leaks into surrounding code.

array_keys returns a list of the array's keys; array_values returns a list of its values. Both drop the original key-to-value association and hand back a fresh, zero-indexed list, which is why array_values is the idiomatic way to close the gaps array_filter leaves behind.

array_map is a transformation: it feeds each value to the callback and builds a brand-new array from the return values. array_walk is a side-effecting visit: it passes each element and its key to the callback and returns only a boolean, so it modifies the original array in place, and only when the value parameter is taken by reference.

A named argument is passed as name: value, so the caller identifies a parameter by its declared name instead of its position. That lets you skip every optional parameter you do not care about and set only the one you need, and it makes a call with several booleans readable. Named arguments must follow any positional ones.

All three sort the array in place, by reference, and return a boolean rather than a new array. sort orders by value and throws the keys away, renumbering from zero. asort orders by value but keeps each key attached to its value. ksort orders by key instead, leaving the values with their keys.

In a call f(...$args) unpacks an array into separate arguments; in a literal [...$a, ...$b] splices arrays together. In a signature it does the opposite — function f(...$rest) collects the remaining arguments into an array. Since PHP 8.1 unpacking also accepts string keys, which behave like named arguments.

They replaced the error-prone strpos idioms. Because strpos returns the position of a hit and false when there is none, a match at offset 0 is falsy, so the check had to be written strpos($h, $n) !== false and a prefix test needed === 0. The three PHP 8 functions return a plain boolean and say what they mean.

An anonymous function captures nothing implicitly — every outer variable must be listed in a use clause, and it is captured by value at the moment the closure is created. An arrow function captures automatically, by value, every outer variable its single expression actually mentions, so it needs no use clause and cannot hold a multi-statement body.

There is only one array type: an ordered hash map whose keys are ints or strings. An indexed array is simply one whose keys happen to be 0..n-1, which array_is_list() checks. Numeric-string keys are cast to int, so $a['8'] and $a[8] are one slot, and order follows insertion.

Use mb_convert_case($string, MB_CASE_TITLE). The multibyte mb_* family is UTF-8 aware, so it uppercases the first letter of each word correctly for Cyrillic. The non-multibyte ucwords treats each byte as a character and corrupts multibyte letters, producing mojibake on привет.

preg_match stops at the first match: it returns 1, 0 or false on error, and fills $matches with one flat array where index 0 is the whole match and the rest are the capture groups. preg_match_all scans the entire subject, returns how many matches it found, and fills $matches with a two-dimensional array grouped by capture group.

Apply the cache-aside (read-through) pattern. Read the cache for $ids, compute the misses with array_diff($ids, array_keys($cached)), return early if none, otherwise fetch the missing ids from the client, write them back to the cache, and return array_merge($cached, $fetched). The injected Cache and Client make the method testable.

Constructor injection makes every dependency explicit in the signature, so the class cannot be built in an invalid state and a reader sees its collaborators at a glance. A service locator hides them inside method bodies: the class now depends on the container itself, a test must configure that global, and a missing binding surfaces only at the moment of the call.

It produces a Closure object bound to that function or method, without calling it. The literal ... is not a spread here: it tells the compiler to build the closure at compile time, so a typo in the name is caught immediately, the scope and $this of a method are captured correctly, and no callable string or array is involved.

JSON is an interchange format: any language can read it, but it carries no class information, so an object comes back as stdClass or an array. serialize is a PHP-only format that restores the original class and even its private properties. Prefer JSON almost always — unserialize on untrusted input is an object-injection vector.

Stream the file line by line with fgets in a loop, so memory stays constant regardless of file size. For each line explode(';', ...) and compare the field to $errorCode. Track elapsed time with microtime(true) and break once it exceeds 100 ms. Crucially fclose the handle (the reference snippet leaks it), and note the budget yields a partial count.

parse_url splits a string into an array of parts on a best-effort basis: it neither validates nor normalises, and it happily accepts a malformed URL. The always-on uri extension gives real objects that parse against a specification — Uri\Rfc3986\Uri for RFC 3986 and Uri\WhatWg\Url for the WHATWG rules — and reject invalid input.

A PHP string is a byte array, so strlen counts bytes, not characters, and a Cyrillic word reports roughly twice its visible length. Worse, substr cuts at a byte offset, so it can slice a multi-byte character in half and emit invalid UTF-8. The mb_* functions from mbstring operate on characters in a declared encoding.

explode splits on one fixed literal separator, with no pattern matching at all — it is the right tool for a CSV line or a colon-separated field, and it is the faster of the two. preg_split splits on a regular expression, so reach for it only when the separator varies: any run of whitespace, or a comma that may be followed by spaces.

The right-hand side must evaluate to a callable that takes exactly one parameter; the left-hand value is passed into it and the result becomes the value of the expression. So $x |> trim(...) |> strtolower(...) chains without nesting. An arrow function on the right must be wrapped in parentheses, and a callable needing two arguments will not fit.

Judge it on readability at the call site, not novelty. The operator only fits a linear chain of single-argument callables, so allow it exactly there — inside transformation pipelines — and forbid it where a step needs a second argument or a branch, since wrapping those in closures is worse than the nesting it replaced. Adopt it in new code first, never as a sweeping rewrite.

Never materialise the body. PHP already spools the upload to a temp file, so open a stream over it, read row by row with fgetcsv, validate as you go, and hand the storage client the stream handle rather than a string, so memory stays at one row plus a buffer. Cap the size in both the web server and PHP, and clean the temp file up on failure.