Operators & Expressions ➕

<?php
// An OPERATOR is a symbol that does something to values (the "operands").
// $a + $b  ->  +  is the operator, $a and $b are the operands.

$a = 15;
$b = 4;

// The six arithmetic operators. Each line builds a string with the . operator
// (more on . in a moment) and echoes the result.
echo "15 + 4  = " . ($a + $b)  . "\n";   // 19    addition
echo "15 - 4  = " . ($a - $b)  . "\n";   // 11    subtraction
echo "15 * 4  = " . ($a * $b)  . "\n";   // 60    multiplication
echo "15 / 4  = " . ($a / $b)  . "\n";   // 3.75  division ALWAYS returns a float here
echo "15 % 4  = " . ($a % $b)  . "\n";   // 3     modulus = the REMAINDER after dividing
echo "15 ** 4 = " . ($a ** $b) . "\n";   // 50625 exponentiation: 15 to the power of 4
?>

15 + 4  = 19
15 - 4  = 11
15 * 4  = 60
15 / 4  = 3.75
15 % 4  = 3
15 ** 4 = 50625

<?php
// PHP joins strings with the DOT ( . ), NOT the + sign.
// (Using + on two strings tries to ADD them as numbers — a classic trap.)

$first = "Ada";
$last  = "Lovelace";

// '.' glues pieces together. Note the literal space " " in the middle.
$fullName = $first . " " . $last;
echo $fullName . "\n";          // Ada Lovelace

// '.=' APPENDS to a string in place — like += but for text.
$greeting = "Hello";
$greeting .= ", " . $first;      // adds ", Ada" onto the end
$greeting .= "!";                // adds "!" onto the end
echo $greeting . "\n";          // Hello, Ada!

// Inside "double quotes" PHP also expands variables directly — handy too.
echo "Welcome back, $first.\n"; // Welcome back, Ada.
?>

Ada Lovelace
Hello, Ada!
Welcome back, Ada.

<?php
// '=' is ASSIGNMENT: it puts the value on the right into the variable on the left.
// The compound operators below do a calculation AND reassign in one step.

$x = 10;            echo "start:  \$x = $x\n";   // start:  $x = 10

$x += 5;            echo "+= 5:   \$x = $x\n";   // 15   same as $x = $x + 5
$x -= 3;            echo "-= 3:   \$x = $x\n";   // 12   same as $x = $x - 3
$x *= 2;            echo "*= 2:   \$x = $x\n";   // 24   same as $x = $x * 2
$x /= 4;            echo "/= 4:   \$x = $x\n";   // 6    same as $x = $x / 4
$x %= 4;            echo "%= 4:   \$x = $x\n";   // 2    same as $x = $x % 4

// ++ and -- add or subtract exactly 1. POSITION matters:
$n = 5;
echo "\$n++ gives " . ($n++) . ", then \$n is $n\n"; // gives 5, then 6 (use-then-add)
echo "++\$n gives " . (++$n) . ", then \$n is $n\n"; // gives 7, then 7 (add-then-use)
?>

start:  $x = 10
+= 5:   $x = 15
-= 3:   $x = 12
*= 2:   $x = 24
/= 4:   $x = 6
%= 4:   $x = 2
$n++ gives 5, then $n is 6
++$n gives 7, then $n is 7

<?php
// COMPARISON operators ask a yes/no question and return a bool (true / false).
// var_export() prints true/false literally so you can SEE the answer.

// == is LOOSE equality: it converts types first, so surprises happen.
// === is STRICT equality: values AND types must match. Prefer === almost always.
echo "5 == '5'   -> "; var_export(5 == "5");   echo "\n"; // true  (string "5" becomes 5)
echo "5 === '5'  -> "; var_export(5 === "5");  echo "\n"; // false (int vs string)
echo "0 == 'a'   -> "; var_export(0 == "a");   echo "\n"; // false (modern PHP 8+)
echo "1 != 2     -> "; var_export(1 != 2);     echo "\n"; // true  (not equal)
echo "3 <= 3     -> "; var_export(3 <= 3);     echo "\n"; // true  (less than OR equal)

// The SPACESHIP <=> returns -1, 0, or 1 for a three-way compare.
// Perfect for sorting: it tells you "smaller", "equal", or "larger".
echo "1 <=> 5 -> " . (1 <=> 5) . "\n";   // -1  left is smaller
echo "5 <=> 5 -> " . (5 <=> 5) . "\n";   //  0  they are equal
echo "9 <=> 5 -> " . (9 <=> 5) . "\n";   //  1  left is larger
?>

5 == '5'   -> true
5 === '5'  -> false
0 == 'a'   -> false
1 != 2     -> true
3 <= 3     -> true
1 <=> 5 -> -1
5 <=> 5 -> 0
9 <=> 5 -> 1

<?php
// 🎯 YOUR TURN — fill in each blank marked ___ , then run it.
// Goal: build a full sentence using arithmetic AND string concatenation.

$price = 8;
$qty   = 3;

// 1) Work out the total cost (price times quantity)
$total = $price ___ $qty;          // 👉 replace ___ with the multiply operator ( * )

// 2) Join the pieces into one string with the DOT operator
echo "Total: " ___ $total ___ " dollars\n"; // 👉 replace each ___ with a dot ( . )

// ✅ Expected output:
//    Total: 24 dollars
?>

Total: 24 dollars

<?php
// LOGICAL operators combine true/false values into a single yes/no answer.
//   &&  AND  -> true only if BOTH sides are true
//   ||  OR   -> true if EITHER side is true
//   !   NOT  -> flips true to false and back

$loggedIn = true;
$isAdmin  = false;

var_export($loggedIn && $isAdmin); echo "  (&&  both? no)\n";  // false
var_export($loggedIn || $isAdmin); echo "  (||  either? yes)\n"; // true
var_export(!$isAdmin);             echo "  (!   flip false)\n";  // true

// 'and' / 'or' are word versions that do the same logic BUT bind very loosely —
// looser than '='. This line surprises people:
$result = true and false;   // reads as ($result = true) and false  -> $result is TRUE
var_export($result);        echo "  (gotcha: 'and' is looser than '=')\n";

// Use && and || to stay safe. This behaves as expected:
$result = true && false;    // $result is FALSE, as you'd hope
var_export($result);        echo "  (&& binds tighter than '=')\n";
?>

false  (&&  both? no)
true  (||  either? yes)
true  (!   flip false)
true  (gotcha: 'and' is looser than '=')
false  (&& binds tighter than '=')

<?php
// ?? NULL COALESCING: "use the left value, but if it's null/unset, use the right."
$username = null;
$name = $username ?? "Guest";     // $username is null, so fall back to "Guest"
echo "name: $name\n";            // name: Guest

// ??= assigns the fallback ONLY if the variable is currently null/unset.
$config = null;
$config ??= "default";            // was null -> becomes "default"
echo "config: $config\n";        // config: default

// TERNARY  condition ? valueIfTrue : valueIfFalse  — a one-line if/else.
$age = 20;
$status = ($age >= 18) ? "adult" : "minor";
echo "status: $status\n";        // status: adult

// SHORT TERNARY ?:  returns the left value if it's "truthy", else the right.
// Careful: ?: checks truthiness ("" and 0 count as false); ?? only checks null.
$nickname = "";
echo "nick: " . ($nickname ?: "Anonymous") . "\n"; // "" is falsy -> Anonymous
?>

name: Guest
config: default
status: adult
nick: Anonymous

<?php
// 🎯 YOUR TURN — choose the RIGHT comparison operator.
// var_export prints true / false so you can check yourself.

$input = "5";   // came from a form, so it's a STRING "5", not the number 5

// 1) We want this to be FALSE because a string is not the same TYPE as a number.
//    Use the STRICT equality operator.
var_export($input ___ 5);  echo "\n";   // 👉 replace ___ with strict-equal ( === )

// 2) We want a fallback when $nickname is null. Use null coalescing.
$nickname = null;
echo ($nickname ___ "Guest") . "\n";    // 👉 replace ___ with the ?? operator

// ✅ Expected output:
//    false
//    Guest
?>

false
Guest

<?php
// PRECEDENCE is the order operators run in, like maths: * before +.
echo 2 + 3 * 4, "\n";        // 14, NOT 20 — * happens before +

// Parentheses ( ) force your own order and make intent obvious.
echo (2 + 3) * 4, "\n";      // 20 — the addition is forced first

// Comparison runs before && / ||, so this reads naturally:
$score = 85;
$pass = $score >= 50 && $score <= 100;  // (score>=50) && (score<=100)
var_export($pass); echo "\n";          // true

// When unsure, ADD PARENTHESES. They cost nothing and remove all doubt.
$ok = ($score >= 50) && ($score <= 100);
var_export($ok); echo "\n";            // true
?>

14
20
true
true