Statements & Expressions

== compares values after type juggling, so an int and a string can be equal; === is true only when type and value both match. Loose rules still surprise after PHP 8.0, so === is the safe default.

Both output strings and are language constructs, not functions. echo accepts several comma-separated arguments and returns nothing; print accepts one argument and always returns 1, so it can appear inside an expression.

Anything after a closing ?> is output, and PHP swallows only the one newline right after the tag. A stray blank line in an included class file then corrupts responses or blocks later headers; omitting ?> removes the risk.

PHP has function scope and global scope, and a function sees only its own variables, so an outer $config is undefined inside it. Pass the value as a parameter; global and $GLOBALS work but hide the dependency.

isset() is true when a variable exists and is not null. empty() is true when it is missing or falsy, such as 0, "0", "" or []. is_null() is a function, true only for null, and warns on undefined variables.

const is a top-level statement with a constant-expression value, prefixed with the current namespace. define() is a function call that runs anywhere, accepts any runtime value and uses its string name exactly as given, with no namespace prefix.

After foreach ($arr as &$value), $value remains a reference to the last element. A later by-value foreach reusing $value writes each element into that slot, leaving it equal to the second-to-last value. unset($value) after the first loop prevents it.

?? falls back when the left side is null or undefined, without a warning; ?: falls back on any falsy value; ??= assigns only when null or unset; ?-> returns null for a null object and skips the rest of the chain.

Magic constants are compiler keywords replaced with facts about where they are written: file, directory, line, function, class, trait, method, namespace or property. They vary by location, are case-insensitive and are invisible to defined() and constant().

constant() and defined() treat their string argument as a fully qualified name: the current namespace is not added and there is no fallback. constant() throws Error for a missing constant since PHP 8.0; defined() just returns false.

break N leaves N enclosing loops or switches; continue N jumps to the next iteration of the Nth one. switch counts as a level, so a plain continue inside it acts like break, and PHP warns you to use continue 2.

By value, foreach iterates the array as it stood when the loop began, so changes made in the body are not visited. By reference, it follows the live array and visits appended elements. Since PHP 7.0 foreach never moves the internal pointer.

$a <=> $b returns an int below, equal to or above zero when $a is less than, equal to or greater than $b. Comparing arrays of fields, [$a->x, $a->y] <=> [$b->x, $b->y], gives a multi-key comparator for usort().

The opening brace becomes a colon and the closing brace an end keyword such as endif; or endforeach;, which keeps templates readable. Traps: write elseif, never mix braces and colons, and output nothing between switch: and its first case.

var_dump() prints types, lengths and values and cannot return a string. print_r() prints a readable view, hides types, and can return a string. var_export() prints valid PHP code, can return it, and rejects circular references.

global $x creates a local reference to the global $x, like $x = &$GLOBALS['x'], so unsetting or rebinding the local name leaves the global alone. Since PHP 8.1, $GLOBALS cannot be written as a whole, only element by element.

A static local keeps its value between calls, and its initialiser runs only on the first call; it lives until the request ends. PHP 8.3 allows any expression as initialiser; since 8.1 inherited methods share it with the parent.

Reading an undefined constant throws an Error since PHP 8.0; PHP 7 turned the bare word into a string. Redeclaring one keeps the first value, warns that PHP 9 will make it an error, and makes define() return false.

switch compared the database string '2' loosely with case 2; match uses ===, so '2' matches no int arm and throws UnhandledMatchError. Validate and cast at the boundary, then decide deliberately how unknown codes should fail.

Loose == accepts numeric look-alikes ("1e2" == "100"), a JSON true against any ordinary code, and null against an empty code. PHP 8.0 fixed only int 0 matching a non-numeric code; require a string and compare with ===.

and, or and xor bind more loosely than =, so the line runs as ($ok = validate($code)) and redeem($code), discarding redeem's result. && and || bind tighter than =. Nested unparenthesised ternaries and == inside bitwise & are the other classic traps.

$b = &$a makes two names share one value. A reference to an array element turns that slot into a shared reference, and copying the array copies the shared slot, so writing the copy changes the original.

A const value must be a constant expression: literals, arrays, operators, other constants, enum cases and, since 8.1, new. PHP 8.5 adds casts, static closures without use() and first-class callables; ordinary function calls and variables are still rejected.

7 / 2 is float(3.5) and 6 / 2 is int(3), because / returns an int only when two ints divide exactly; 1 / 0 throws DivisionByZeroError since PHP 8.0; -2 ** 2 is int(-4) because ** binds tighter than unary minus.

$$name uses the value of $name as the name of another variable, so $name = 'temp'; $$name = 21; sets $temp. Braces resolve array ambiguity. Codebases avoid them because tools cannot follow them and user-controlled names can overwrite any variable.

var_export($value, true) returns a PHP literal, so a file containing '<?php return ' plus that literal is a cache that include loads directly. It suits arrays, scalars, enums and stdClass; other objects need __set_state(), and cycles export as NULL.