1. Parentheses - The Highest Precedence

Parentheses always have the highest precedence. They allow you to explicitly control the order of operations:

<?php
// Parentheses change the evaluation order
$a = 5;
$b = 3;
$c = 2;

// Without parentheses
$result1 = $a + $b * $c;
echo "Without parentheses: $a + $b * $c = $result1<br>"; // 11

// With parentheses
$result2 = ($a + $b) * $c;
echo "With parentheses: ($a + $b) * $c = $result2<br>"; // 16

// Multiple levels of parentheses
$result3 = ($a + ($b * $c)) / 2;
echo "Nested parentheses: ($a + ($b * $c)) / 2 = $result3<br>"; // 5.5
?>

Best Practice: Use parentheses liberally to make your code more readable and to ensure operations are performed in the intended order, even when the default precedence would give the same result.

2. Arithmetic Operators

Arithmetic operators follow a precedence similar to mathematical conventions:

<?php
// Arithmetic operators precedence
$result1 = 10 + 20 * 3 - 40 / 5;
echo "10 + 20 * 3 - 40 / 5 = $result1<br>"; // 10 + 60 - 8 = 62

// Using parentheses for clarity
$result2 = 10 + (20 * 3) - (40 / 5);
echo "10 + (20 * 3) - (40 / 5) = $result2<br>"; // Same result, but clearer

// Exponentiation has higher precedence than multiplication
$result3 = 2 * 3 ** 2;
echo "2 * 3 ** 2 = $result3<br>"; // 2 * 9 = 18 (not 6^2 = 36)

// Modulus has same precedence as multiplication
$result4 = 10 + 20 % 3 * 2;
echo "10 + 20 % 3 * 2 = $result4<br>"; // 10 + (2 * 2) = 14
?>

Key Points:

• Exponentiation (**) has higher precedence than multiplication, division, and modulus
• Multiplication (*), division (/), and modulus (%) have equal precedence
• Addition (+) and subtraction (-) have equal precedence, lower than multiplication/division

3. String Concatenation

The string concatenation operator (.) has the same precedence as addition and subtraction:

<?php
// String concatenation precedence
$name = "John";
$greeting = "Hello, " . $name . "! Today is " . date('l');
echo $greeting . "<br>";

// Concatenation and arithmetic
$a = 5;
$b = 10;
$result = "The sum is: " . $a + $b; // Caution! This doesn't work as expected
echo $result . "<br>"; // Warning: A non-numeric value...

// Correct way with parentheses
$result = "The sum is: " . ($a + $b);
echo $result . "<br>"; // The sum is: 15

// Concatenation vs. addition
$num1 = "10";
$num2 = "20";
$result1 = $num1 + $num2; // Addition (strings converted to numbers)
$result2 = $num1 . $num2; // Concatenation
echo "$num1 + $num2 = $result1 (numeric addition)<br>"; // 30
echo "$num1 . $num2 = $result2 (string concatenation)<br>"; // 1020
?>

Caution: Be particularly careful when mixing string concatenation with other operators. Use parentheses to clearly indicate your intent.

4. Comparison and Logical Operators

Understanding the precedence between comparison and logical operators is crucial for writing correct conditional expressions:

<?php
// Comparison and logical operators
$a = 5;
$b = 10;
$c = 15;

// Logical operators precedence
$result1 = $a < $b && $b < $c;
echo "($a < $b) && ($b < $c) = " . ($result1 ? 'true' : 'false') . "<br>"; // true

// Comparison has higher precedence than logical operators
$result2 = $a < $b && $b > $c;
echo "($a < $b) && ($b > $c) = " . ($result2 ? 'true' : 'false') . "<br>"; // false

// AND vs OR precedence
$result3 = $a < $b || $b > $c && $a < $c;
// Evaluated as: $a < $b || ($b > $c && $a < $c)
echo "$a < $b || $b > $c && $a < $c = " . ($result3 ? 'true' : 'false') . "<br>"; // true

// Using parentheses for different logic
$result4 = ($a < $b || $b > $c) && $a < $c;
echo "($a < $b || $b > $c) && $a < $c = " . ($result4 ? 'true' : 'false') . "<br>"; // true

// Different result with different parentheses
$result5 = $a < $b || ($b > $c && $a < $c);
echo "$a < $b || ($b > $c && $a < $c) = " . ($result5 ? 'true' : 'false') . "<br>"; // true
?>

Key Points:

• Comparison operators (<, >, <=, >=, ==, ===, etc.) have higher precedence than logical operators
• && (logical AND) has higher precedence than || (logical OR)
• The word-form operators (and, or, xor) have lower precedence than their symbolic counterparts

5. Assignment Operators

Assignment operators have very low precedence, which can lead to some surprising behavior:

<?php
// Assignment operator precedence
$a = 5;
$b = 10;

// Assignment vs. comparison
if ($c = $a + $b) {
    echo "This will execute because $c is 15 (truthy)<br>";
}

// Correct comparison (using ==)
if ($c == $a + $b) {
    echo "This checks if $c equals " . ($a + $b) . "<br>";
}

// Multiple assignments
$x = $y = $z = 0;
echo "After $x = $y = $z = 0: x = $x, y = $y, z = $z<br>";

// Assignment in expressions
$total = 0;
$numbers = [1, 2, 3, 4, 5];
foreach ($numbers as $num) {
    // The assignment happens, then the value is added to $total
    echo "Total += " . ($total += $num) . "<br>";
}
?>

Caution: The low precedence of assignment operators is often the source of bugs, especially when mistakenly using = (assignment) instead of == (comparison) in conditional statements.

6. Different Precedence: Symbolic vs. Word Form Operators

PHP provides both symbolic (&&, ||) and word form (and, or) logical operators, with different precedence levels:

<?php
// Symbolic vs. word form operators
$a = true;
$b = false;
$c = true;

// && (higher precedence) vs. and (lower precedence)
$result1 = $a && $b; // $a && $b = false
$result2 = $a and $b; // Interpreted as: ($a) and $b, which is true and false = false

// This is where it gets tricky
$var1 = $a && $b;     // $var1 = false
$var2 = $a and $b;    // Interpreted as: ($var2 = $a) and $b, so $var2 = true!

echo "Using &&: " . ($var1 ? 'true' : 'false') . "<br>"; // false
echo "Using and: " . ($var2 ? 'true' : 'false') . "<br>"; // true!

// || (higher precedence) vs. or (lower precedence)
$var3 = $a || $b;     // $var3 = true
$var4 = $a or $b;     // Interpreted as: ($var4 = $a) or $b, so $var4 = true

echo "Using ||: " . ($var3 ? 'true' : 'false') . "<br>"; // true
echo "Using or: " . ($var4 ? 'true' : 'false') . "<br>"; // true (same result this time)

// Mixing with assignment (very tricky!)
$var5 = false || true;  // $var5 = true
$var6 = false or true;  // Interpreted as: ($var6 = false) or true, so $var6 = false!

echo "false || true results in: " . ($var5 ? 'true' : 'false') . "<br>"; // true
echo "false or true results in: " . ($var6 ? 'true' : 'false') . "<br>"; // false!
?>

Best Practice: For clarity and to avoid subtle bugs, prefer the symbolic operators (&&, ||) over the word forms (and, or). If you do use the word forms, always use parentheses to clarify your intent.