.PHP File Format – Expressions

Operator precedence

Operators are listed from highest to lowest precedence, following the manual’s precedence table. Operators in the same row have equal precedence.

• Non-associative means the operators cannot be chained without parentheses. 1 < 2 < 3 and 1 == 2 == 3 are parse errors. a ? b : c ? d : e is a compile error.
• Concatenation. Since PHP 8.0 . binds less tightly than +, -, << and >>, so "x" . 1 + 2 is "x3". Before 8.0 it had the same precedence as + and - and a higher one than the shifts.
• and and or are lower than =. $a = true and false; assigns true, because it is ($a = true) and false. Use && and || when an expression includes assignment.
• Assignment inside prefix operators. !$a = f() parses as !($a = f()), because the left side of = must be a variable.
• Exponent. ** binds more tightly than unary minus: -2 ** 2 is -4. It is right-associative: 2 ** 3 ** 2 is 512.
• Evaluation order. Precedence groups the operands but does not fix the order in which they are evaluated. Avoid writing expressions such as $i + $i++, whose result is not defined.

Arithmetic operators

Integer results that do not fit become floats. intdiv() gives integer division. It throws DivisionByZeroError on zero and ArithmeticError for PHP_INT_MIN divided by -1. Non-numeric operands behave as under Numeric strings.

Assignment

• $a = 1 is an expression whose value is what was assigned, so $a = $b = 1 works from right to left.
• $a = &$b assigns by reference.
• Compound forms, such as $a += 1, read and then write the variable. They exist for every arithmetic, bitwise and string operator, plus ??= (PHP 7.4), which assigns only if the left side is not set or is null.
• The left side can be a destructuring pattern. See Destructuring.

Comparison operators

The conversion rules are given in full under Comparison.

Logical operators

&&, ||, and and or evaluate the right operand only if the left does not already decide the result. ! negates. xor is true when exactly one operand is true. Every operator yields a bool.

Bitwise operators

Ternary and null coalescing

• $a ? $b : $c evaluates only the chosen branch. Nesting without parentheses is an error since PHP 8.0.
• $a ?: $b (PHP 5.3) gives $a if it is truthy, otherwise $b, evaluating $a once. A chain of these is stable.
• $a ?? $b (PHP 7.0) gives $a if it exists and is not null, otherwise $b. It behaves like isset(), so an undefined variable, key or property on the left raises no warning. Its precedence is low, so parenthesise it inside a larger expression: 'Mr ' . ($name ?? 'Anon').

Other operators

Nullsafe operator

$a?->b (PHP 8.0) behaves like $a->b unless $a is null, when the whole chain gives null.

$city = $user?->address?->city;            // null if $user or the address is null
$name = $user?->getName(makeDefault());    // makeDefault() is not called if $user is null

It is for reading only: $a?->b = 1 is a compile error. It applies only to null. Calling a method on another non-object still throws. It works inside isset() and empty().

Match

match (PHP 8.0) is an expression that selects one arm using strict comparison.

match ( subject ) {
    condition {, condition} [,] => expression ,
    default => expression [,]
}

$label = match ($code) {
    200, 201 => 'ok',
    404      => 'not found',
    default  => throw new RuntimeException("Unknown code $code"),
};

• The subject is compared with ===, so "1" does not match 1. switch uses ==.
• Conditions are tried in order, and only until one matches. Only the matching arm’s result is evaluated.
• An arm may have several conditions separated by commas. There is no fall-through, and there is no break.
• With no match and no default, an UnhandledMatchError is thrown. Only one default is allowed.
• The body of an arm is a single expression. Use a closure or function for several statements. throw is an expression, so it can be an arm.
• The subject can be omitted by writing match (true) and using boolean conditions. They must be exactly true or false.
• As a statement, a match needs a semicolon after its closing brace.

Arrays

An array is an ordered list of key and value pairs. Short syntax (5.4 for literals) and the older array() are the same thing.

$list = [1, 2, 3,];              // the trailing comma is allowed
$map  = ['a' => 1, 'b' => 2];
$old  = array(1, 2);
$map['c'] = 3;
$list[] = 4;                     // appends with the next key
echo $map['a'], $list[0];

• Writing the same key twice keeps the last value.
• $a[] = $v uses one more than the largest integer key the array has held since it was last reindexed, even if that key is gone now. An empty array starts at 0.
• Since PHP 8.3, after a negative key n, the next key is n + 1 rather than 0.
• Assigning to a key of a variable that is null or undefined creates an array. Doing it to false is deprecated since 8.1. Doing it to any other scalar throws Error.
• Elements of an array are ordered by insertion, not by key.

[$a, $b] = [1, 2];                  // $a = 1, $b = 2
[, , $third] = [1, 2, 3];           // skip positions
['x' => $x, 'y' => $y] = $point;    // by key
[[$p, $q], $r] = [[1, 2], 3];       // nested
[$a, $b] = [$b, $a];                // swap
foreach ($rows as ['id' => $id, 'name' => $name]) {}

$a = [1, 2];
$b = [0, ...$a, 3];              // [0, 1, 2, 3]
$c = [...['x' => 1], ...['x' => 2, 'y' => 3]];  // ['x' => 2, 'y' => 3]
echo max(...$b);                 // 3

Pipe operator

$value |> $callable (PHP 8.5) passes the value on the left to the callable on the right and gives its result. It is left-associative, so calls chain from top to bottom.

$slug = ' PHP 8.5 Released '
    |> trim(...)
    |> strtolower(...)
    |> (fn($s) => str_replace(' ', '-', $s));
// "php-8.5-released"

• The right side must be a callable, or an expression that evaluates to one. Anything else throws Error.
• The callable receives exactly one argument. A function with a further required parameter fails as if it had been called with too few arguments.
• A function that takes its parameter by reference is not allowed.