PHP Operators — Why Loose Equality Exposes User Accounts

Every useful program ever written does at least one of three things: it calculates something, it compares something, or it makes a decision. None of those three things are possible without operators. Whether you're building a shopping cart that totals an order, a login form that checks if a password matches, or a news feed that filters posts by date — operators are working silently behind every single line of that logic. They are the engine of your code.

Before operators existed in programming languages, developers had to write verbose machine-level instructions just to add two numbers. Operators solve this by giving us a clean, readable shorthand. Instead of writing a function call like add($price, $tax), you just write $price + $tax. Instead of a function like isGreaterThan($age, 18), you write $age > 18. Operators compress complex intentions into a single character or short symbol — and PHP has a rich set of them covering arithmetic, comparison, logic, assignment, string manipulation and more.

By the end of this article you'll understand every major category of PHP operator, know exactly when to reach for each one, be able to read and write real PHP logic without second-guessing yourself, and you'll know the two or three sneaky mistakes that trip up even experienced developers. Let's build this up from the ground floor.

Why PHP Operators Are a Security Boundary, Not Just Syntax

PHP operators are symbols that perform operations on values and variables. The core mechanic is that they define how values are compared, combined, or transformed — but the critical distinction is between loose (==) and strict (===) equality. Loose equality performs type juggling before comparison, meaning '1' == 1 is true, while strict equality checks both value and type. This is not a minor detail; it's a fundamental behavior that determines how your application handles authentication, authorization, and data validation. Loose equality coerces strings to numbers, objects to arrays, and nulls to empty strings, creating implicit conversion paths that often bypass intended logic. In practice, this means a user input of '0e12345' compared with == to a password hash starting with '0e' can evaluate as true because PHP interprets both as scientific notation numbers equal to zero. This is not theoretical — it has been exploited in real-world authentication bypasses. Use strict equality (===) for all security-sensitive comparisons, including password verification, session tokens, and user IDs. Loose equality is only safe when you explicitly intend type coercion, such as checking if a form field is empty with == ''.

Arithmetic Operators — PHP as Your Calculator

Arithmetic operators are the ones you already know from primary school maths — they perform mathematical calculations on numbers. PHP gives you addition (+), subtraction (-), multiplication (), division (/), modulus (%), and exponentiation (*).

The one you might not recognise is modulus (%). It gives you the remainder after a division. So 10 % 3 is 1, because 3 goes into 10 three times (that's 9), leaving 1 left over. This is incredibly useful for things like checking whether a number is even or odd — an even number always has a remainder of 0 when divided by 2.

Exponentiation () is also worth highlighting. 2 8 means '2 to the power of 8', which is 256. You'll see this in security calculations, image sizing logic, and anywhere exponential growth matters.

PHP follows standard mathematical order of operations — multiplication and division before addition and subtraction. Use parentheses to override that order and make your intention crystal clear to anyone reading your code later.

<?php

// Imagine you're building a simple invoice calculator
$itemPrice   = 49.99;   // price of one item in dollars
$quantity    = 3;        // how many the customer ordered
$discountPct = 10;       // 10% discount
$taxRate     = 0.08;     // 8% sales tax as a decimal

// --- Addition ---
$shippingFee = 5.99;
$subtotalWithShipping = $itemPrice + $shippingFee; // adds two values
echo "Item + Shipping: $" . $subtotalWithShipping . "\n"; // 55.98

// --- Subtraction ---
$refundAmount = 10.00;
$amountAfterRefund = $itemPrice - $refundAmount;  // removes the refund
echo "After Refund: $" . $amountAfterRefund . "\n"; // 39.99

// --- Multiplication ---
$lineTotal = $itemPrice * $quantity; // price times quantity = line total
echo "Line Total: $" . $lineTotal . "\n"; // 149.97

// --- Division ---
$discountAmount = ($discountPct / 100) * $lineTotal; // calculate discount value
echo "Discount Amount: $" . $discountAmount . "\n"; // 14.997

// --- Modulus (remainder after division) ---
$totalItems = 10;
$itemsPerBox = 3;
$leftoverItems = $totalItems % $itemsPerBox; // 10 divided by 3 = 3 remainder 1
echo "Items that won't fit in a full box: " . $leftoverItems . "\n"; // 1

// A classic use: check if a number is even or odd
$orderNumber = 4582;
if ($orderNumber % 2 === 0) {
    echo "Order #" . $orderNumber . " is an even-numbered order.\n";
} else {
    echo "Order #" . $orderNumber . " is an odd-numbered order.\n";
}

// --- Exponentiation ---
$base = 2;
$power = 10;
$result = $base ** $power; // 2 to the power of 10
echo "2 to the power of 10 is: " . $result . "\n"; // 1024

// --- Order of operations matters! ---
$wrongTotal  = $itemPrice * $quantity + $discountPct / 100; // PHP does * and / first
$correctTotal = ($itemPrice * $quantity) + ($discountPct / 100); // parentheses = intention is clear
echo "Wrong-looking (but technically same here): $" . $wrongTotal . "\n";
echo "With parentheses (explicit intention): $" . $correctTotal . "\n";

Assignment Operators — Storing and Updating Values in One Move

The basic assignment operator is =. But here's something beginners always get confused about: in PHP (and most programming languages), = does NOT mean 'equals'. It means 'take the value on the right and store it in the variable on the left'. Think of it like putting a label on a jar.

$score = 100 means: create a jar called score, and put the number 100 inside it.

PHP also gives you compound assignment operators that combine a maths operation with an assignment in one step. Instead of writing $score = $score + 10, you can write $score += 10. These aren't just shortcuts — they make your code easier to read because they communicate 'I am changing this existing value' rather than 'I am creating a new value'.

These compound operators exist for all arithmetic operations: +=, -=, =, /=, %=, *=. There's also .= for strings, which appends text to an existing string variable — something you'll use constantly when building HTML output or log messages.

Using these operators correctly is a sign of confident, fluent PHP code.

<?php

// --- Basic Assignment ---
$playerName  = "Alex";    // store the string "Alex" in $playerName
$playerScore = 0;          // player starts with zero points
$playerLevel = 1;          // player starts at level 1

echo "Starting state — Player: $playerName, Score: $playerScore, Level: $playerLevel\n";

// --- += (add and assign) ---
// Player picks up a coin worth 50 points
$playerScore += 50; // same as: $playerScore = $playerScore + 50
echo "After coin pickup — Score: $playerScore\n"; // 50

// Player gets a time bonus of 30 points
$playerScore += 30;
echo "After time bonus — Score: $playerScore\n"; // 80

// --- -= (subtract and assign) ---
// Player takes damage and loses 15 points
$playerScore -= 15; // same as: $playerScore = $playerScore - 15
echo "After taking damage — Score: $playerScore\n"; // 65

// --- *= (multiply and assign) ---
// Player activates a double-score power-up!
$playerScore *= 2; // same as: $playerScore = $playerScore * 2
echo "After double-score power-up — Score: $playerScore\n"; // 130

// --- /= (divide and assign) ---
// Score gets halved for using a hint
$playerScore /= 2; // same as: $playerScore = $playerScore / 2
echo "After hint penalty — Score: $playerScore\n"; // 65

// --- %= (modulus and assign) ---
// Rarely used, but here's a real example:
// "Wrap" the level number to stay within 1-5 cycle
$currentLevel = 7;
$currentLevel %= 5; // 7 % 5 = 2, wraps back into range 0-4
echo "Wrapped level (0-indexed): $currentLevel\n"; // 2

// --- .= (concatenate and assign) — extremely useful for building strings ---
$gameLog  = "[LOG] Game started. ";
$gameLog .= "Player $playerName joined. ";  // appends to existing string
$gameLog .= "Final score: $playerScore.";   // appends again
echo $gameLog . "\n";

Comparison and Logical Operators — The Decision-Making Duo

Comparison operators let PHP evaluate whether something is true or false by comparing two values. Every if statement, every loop condition, every filter you write depends on them. They always return a boolean — either true or false.

The most important distinction in PHP comparisons is == versus ===. Double-equals (==) checks if two values are loosely equal — PHP will try to convert types before comparing. Triple-equals (===) checks if two values are strictly equal — same value AND same type. This difference causes some of the nastiest bugs in PHP.

Logical operators combine multiple comparisons into one decision. && (AND) means both conditions must be true. || (OR) means at least one must be true. ! (NOT) flips a boolean — true becomes false and vice versa.

Think of && and || like real-world logic: 'You can enter the club if you have ID AND you're over 18' is &&. 'You get a discount if you're a student OR a senior' is ||.

There's also the spaceship operator <=>, which returns -1, 0, or 1 — perfect for sorting. And the null coalescing operator ??, which is one of PHP's most practical modern features.

<?php

// ===========================
// COMPARISON OPERATORS
// ===========================

$userAge        = 20;
$minimumAge     = 18;
$membershipTier = "gold";

// == (loose equality — compares VALUE only, converts types)
$numericString = "20";  // this is a STRING, not an integer
var_dump($userAge == $numericString);   // true — PHP converts "20" to 20 before comparing

// === (strict equality — compares VALUE and TYPE)
var_dump($userAge === $numericString);  // false — 20 (int) is not identical to "20" (string)

// != (not equal, loose)
var_dump($userAge != 18);  // true — 20 is not equal to 18

// !== (not identical, strict)
var_dump($userAge !== $numericString); // true — different types

// > < >= <=
var_dump($userAge > $minimumAge);   // true — 20 is greater than 18
var_dump($userAge >= $minimumAge);  // true — 20 is greater than or equal to 18
var_dump($userAge < 25);            // true — 20 is less than 25
var_dump($userAge <= 20);           // true — 20 is less than or equal to 20

echo "\n";

// Spaceship operator <=> (returns -1, 0, or 1)
// Great for custom sort functions
$priceA = 29.99;
$priceB = 49.99;
$comparison = $priceA <=> $priceB; // -1 means left is LESS THAN right
echo "Spaceship result: " . $comparison . "\n"; // -1

// ===========================
// LOGICAL OPERATORS
// ===========================

$isLoggedIn      = true;
$hasVerifiedEmail = true;
$isAdminUser     = false;
$isBannedUser    = false;

// && (AND) — both must be true
if ($isLoggedIn && $hasVerifiedEmail) {
    echo "Access granted: user is logged in AND has verified email.\n";
}

// || (OR) — at least one must be true
if ($isAdminUser || $hasVerifiedEmail) {
    echo "Can post content: user is admin OR has verified email.\n";
}

// ! (NOT) — flips the boolean
if (!$isBannedUser) {
    echo "User is not banned — showing dashboard.\n";
}

// Combining conditions
$canPublishPost = $isLoggedIn && $hasVerifiedEmail && !$isBannedUser;
echo "Can publish post: " . ($canPublishPost ? 'Yes' : 'No') . "\n"; // Yes

// Null coalescing operator ?? (PHP 7+)
// Returns the LEFT side if it's set and not null, otherwise returns the RIGHT side
$username = null;
$displayName = $username ?? "Guest"; // $username is null, so use "Guest"
echo "Welcome, " . $displayName . "!\n"; // Welcome, Guest!

$loggedInUsername = "sarah_dev";
$displayName2 = $loggedInUsername ?? "Guest"; // $loggedInUsername is set, so use it
echo "Welcome, " . $displayName2 . "!\n"; // Welcome, sarah_dev!

String Operators and Concatenation

The dot operator (.) is PHP's string concatenation operator. It joins two strings into one. 'Hello' . ' World' produces 'Hello World'. You'll use it constantly when building messages, HTML, or any textual output.

There's also the compound assignment version (.=) which appends a string to the end of an existing variable. $str .= ' more text' is equivalent to $str = $str . ' more text'. This is your go-to tool for building strings in loops, constructing SQL queries, or accumulating log messages.

One subtle behavior: PHP automatically converts numbers to strings when using the dot operator. So 42 . ' apples' becomes '42 apples'. But be aware that concatenation has lower precedence than arithmetic, so 'Result: ' . 5 + 3 gives 'Result: 8'? Actually it gives '8' because the addition happens first — always wrap arithmetic in parentheses when concatenating.

<?php

// --- Basic Concatenation ---
$firstName = "John";
$lastName  = "Doe";
$fullName  = $firstName . " " . $lastName;
echo "Full name: " . $fullName . "\n"; // John Doe

// Building a sentence
$noun = "fox";
$verb = "jumps";
$sentence = "The quick brown " . $noun . " " . $verb . " over the lazy dog.";
echo $sentence . "\n";

// Number to string conversion
$count = 5;
echo "You have " . $count . " new messages.\n"; // You have 5 new messages.

// ----- Compound assignment .= -----
$logMessage = "[START] ";
$logMessage .= "User logged in. ";
$logMessage .= "IP 192.168.1.1. ";
$logMessage .= "[END]";
echo $logMessage . "\n"; // [START] User logged in. IP 192.168.1.1. [END]

// ----- Precedence Gotcha -----
$price = 10;
$tax = 2;
// Intent: "Total: 12"
$result1 = "Total: " . $price + $tax;  // Warning: + has higher precedence than .
echo "Without parentheses: " . $result1 . "\n"; // 12 (but produces a warning in PHP 8)
$result2 = "Total: " . ($price + $tax); // Correct
echo "With parentheses: " . $result2 . "\n"; // Total: 12

Increment, Decrement, Ternary, and Null-Safe Operators

PHP has a few more operator types that you'll use every day, and skipping them would leave real gaps in your understanding.

Increment and decrement operators (++ and --) increase or decrease a number by exactly 1. They come in two flavours: pre (++$count) changes the value first, then returns it. Post ($count++) returns the current value first, then changes it. This subtlety matters inside expressions.

The ternary operator (?:) is a compact if/else on one line. $result = condition ? 'if true' : 'if false'. Use it for simple assignments — not for complex logic where a full if/else is clearer.

The null-safe operator (?->, PHP 8.0+) lets you safely call methods on an object that might be null, without throwing an error. Before it existed, you'd need an if ($obj !== null) check every single time. Now one ?-> handles it gracefully.

<?php

// ===========================
// INCREMENT / DECREMENT
// ===========================

$pageViews = 100;

// Post-increment: RETURNS current value, THEN increments
$viewsBeforeIncrement = $pageViews++;  // $viewsBeforeIncrement gets 100, THEN $pageViews becomes 101
echo "Returned value (post-increment): " . $viewsBeforeIncrement . "\n"; // 100
echo "pageViews after post-increment:  " . $pageViews . "\n";             // 101

// Pre-increment: INCREMENTS first, THEN returns new value
$newPageViews = ++$pageViews;  // $pageViews becomes 102, THEN $newPageViews gets 102
echo "Returned value (pre-increment):  " . $newPageViews . "\n"; // 102
echo "pageViews after pre-increment:   " . $pageViews . "\n";    // 102

// Decrement works the same way
$stockCount = 5;
$stockCount--; // post-decrement — one item sold
echo "Stock remaining: " . $stockCount . "\n"; // 4

echo "\n";

// ===========================
// TERNARY OPERATOR (?:)
// ===========================

$cartItemCount = 3;

// Long way:
if ($cartItemCount > 0) {
    $cartStatus = "Items in cart";
} else {
    $cartStatus = "Cart is empty";
}

// Ternary — same logic, one line:
$cartStatus = ($cartItemCount > 0) ? "Items in cart" : "Cart is empty";
echo "Cart status: " . $cartStatus . "\n"; // Items in cart

// Real use — displaying user role label
$isAdmin   = false;
$roleLabel = $isAdmin ? "Administrator" : "Standard User";
echo "Role: " . $roleLabel . "\n"; // Standard User

echo "\n";

// ===========================
// NULL-SAFE OPERATOR (?->) — PHP 8.0+
// ===========================

class UserProfile {
    public string $bio;
    public function __construct(string $bio) {
        $this->bio = $bio;
    }
    public function getBio(): string {
        return $this->bio;
    }
}

// Simulate a user that exists and one that doesn't
$activeUser  = new UserProfile("Full-stack developer from Toronto.");
$deletedUser = null; // this user no longer exists

// Without null-safe operator, you'd need:
// if ($deletedUser !== null) { $bio = $deletedUser->getBio(); } else { $bio = null; }

// With null-safe operator (?->) — clean and safe:
$activeBio  = $activeUser?->getBio();  // works fine, returns the bio
$deletedBio = $deletedUser?->getBio(); // $deletedUser is null — returns null safely, no error

echo "Active user bio: " . ($activeBio ?? 'No bio available') . "\n";
echo "Deleted user bio: " . ($deletedBio ?? 'No bio available') . "\n";

Bitwise and Type Operators — Low-Level Power and Type Safety

PHP also provides bitwise operators (&, |, ^, ~, <<, >>) that work on the binary representation of integers. These are often used for flags, permissions, or low‑level data manipulation. For example, you can pack multiple boolean flags into a single integer using bitwise OR and check them with AND.

Type operators help you inspect and enforce variable types. instanceof checks whether an object is an instance of a specific class (or implements an interface). The @ error control operator suppresses errors from an expression — but use it sparingly, as it often hides real problems.

Bitwise operators have lower precedence than comparison operators, so always parenthesize your expressions when mixing them.

<?php

// ===========================
// BITWISE OPERATORS
// ===========================

// Define permission flags as powers of 2
$PERMISSION_READ   = 1;   // 001
$PERMISSION_WRITE  = 2;   // 010
$PERMISSION_EXECUTE = 4;  // 100

// Assign user permissions using bitwise OR
$userPermissions = $PERMISSION_READ | $PERMISSION_EXECUTE; // 101 = 5

// Check permissions using bitwise AND
if ($userPermissions & $PERMISSION_READ) {
    echo "User has READ permission.\n";
}
if ($userPermissions & $PERMISSION_WRITE) {
    echo "User has WRITE permission.\n";
} else {
    echo "User does NOT have WRITE permission.\n";
}

// Bitwise shift
$value = 4; // 100 in binary
$shiftedLeft = $value << 1;  // 1000 = 8
$shiftedRight = $value >> 1; // 10   = 2
echo "4 << 1 = " . $shiftedLeft . "\n";
echo "4 >> 1 = " . $shiftedRight . "\n";

// ===========================
// TYPE OPERATORS
// ===========================

class User {};
class Admin extends User {};

$user = new Admin();
echo "Is user an instance of User? " . ($user instanceof User ? "Yes" : "No") . "\n"; // Yes
echo "Is user an instance of Admin? " . ($user instanceof Admin ? "Yes" : "No") . "\n"; // Yes

// Error control operator @ — suppress warnings (use sparingly)
$result = @file_get_contents("nonexistent.txt"); // Suppresses warning, $result = false
if ($result === false) {
    echo "File not found (error suppressed).\n";
}

Array Operators — Merging Without the Side Effects

Array operators don't get enough respect until you're debugging why a merge silently dropped a key. The + operator is not array_merge. It's a union that keeps the left operand's keys if they already exist. That means $a + $b is the same as writing: take everything from $a, then append anything from $b that isn't already set. No overwrites. No surprises. Use this when you want default values that never get overridden — like config arrays. == and === compare arrays structurally. === checks order and types too. That catches you when two arrays have the same values but different internal pointers. If you're ever tempted to serialize() just to compare arrays, stop. Use ===. It's faster and doesn't serialize the whole object graph. The null coalescing operator ?? also works on arrays: $config['timeout'] ?? 30 won't throw an undefined index notice. Use that instead of isset() chains.

// io.thecodeforge — php tutorial

$defaults = [
    'host' => 'localhost',
    'port' => 5432,
    'timeout' => 30,
];

$user_config = [
    'host' => 'prod-db.internal',
    'port' => 5432,
    'dbname' => 'orders',
];

// Union keeps first-match keys — user config wins
$merged = $user_config + $defaults;

var_dump($merged);
/*
array(4) {
  ["host"]=> string(19) "prod-db.internal"
  ["port"]=> int(5432)
  ["dbname"]=> string(6) "orders"
  ["timeout"]=> int(30)
}
*/

Execution Operators — Backticks Are a Production Footgun

Backticks in PHP run shell commands. $output = \ls -la\; returns stdout as a string. That's all it does. No error handling. No stderr. No timeout. No control. In production, that's a footgun. One runaway gzip process or a missing binary and your script hangs indefinitely — or worse, exposes internal data if you accidentally interpolate user input. The shell_exec() function does the same thing but is more explicit. At least it's easier to grep for in a code review. Never, ever pass unsanitised input into a backtick expression. That's a command injection vulnerability waiting to happen. If you must execute a system command, use proc_open() or symfony/process. Those give you timeout, stderr capture, and proper exit code handling. Backticks are fine for one-liner dev scripts on your local machine. That's it.

// io.thecodeforge — php tutorial

$target = $_GET['host'] ?? '';
// NEVER DO THIS — direct user input into backticks
$result = `ping -c 2 $target`;
echo $result;

// Safer but still not great — no timeout, no stderr
$escaped = escapeshellarg($target);
$result = `ping -c 2 $escaped`;
echo $result;

// The right way: use symfony/process or proc_open
// proc_open gives you pipes for stdin/stdout/stderr + exit codes

Nullsafe Operator ?-> (PHP 8.0)

The nullsafe operator ?-> was introduced in PHP 8.0 to simplify chained method calls or property accesses on potentially null values. Instead of writing nested null checks, you can use ?-> to short-circuit the chain if any element is null, returning null immediately. This is particularly useful when working with deeply nested objects from APIs or databases.

Consider a scenario where you have a user object that may have an address, and that address may have a city. Without the nullsafe operator, you'd write:

$city = null;
if ($user !== null) {
    $address = $user->getAddress();
    if ($address !== null) {
        $city = $address->getCity();
    }
}

With the nullsafe operator, this becomes:

$city = $user?->getAddress()?->getCity();

If $user is null, the entire expression returns null without throwing an error. Similarly, if getAddress() returns null, the chain stops and returns null.

Important: The nullsafe operator only works for method calls and property accesses, not for array accesses or function calls. Also, it cannot be used on the left side of an assignment.

This operator is a game-changer for readability and reduces boilerplate null-checking code. However, be cautious: overusing it can mask logic errors where a null value is unexpected. Use it when null is a valid and expected state.

<?php

class Address {
    public function getCity(): ?string {
        return 'New York';
    }
}

class User {
    public function getAddress(): ?Address {
        return new Address();
    }
}

$user = new User();
$city = $user?->getAddress()?->getCity();
echo $city; // Output: New York

$user = null;
$city = $user?->getAddress()?->getCity();
echo $city; // Output: (nothing, null)

Null Coalescing Assignment ??= (PHP 7.4)

The null coalescing assignment operator ??= was introduced in PHP 7.4 as a shorthand for assigning a value only if the variable is null. It combines the null coalescing operator ?? with assignment. The syntax $var ??= $value is equivalent to $var = $var ?? $value. This is extremely useful for setting default values without overwriting existing non-null values.

For example, consider a configuration array where you want to set a default value for a key only if it's not already set:

``php $config['timeout'] ??= 30; ``

This is much cleaner than:

``php if (!isset($config['timeout'])) { $config['timeout'] = 30; } ``

Or using the ternary operator:

``php $config['timeout'] = $config['timeout'] ?? 30; ``

The ??= operator works with any variable, including array elements and object properties. It only assigns if the current value is null (or undefined, which is treated as null). Note that it does not check for empty strings or zero; only null (and undefined) triggers the assignment.

This operator is particularly handy in loops or when processing data where you want to ensure a default value without overwriting existing data. It improves readability and reduces the chance of errors from manual null checks.

<?php

$config = [
    'host' => 'localhost',
    'port' => null,
];

$config['port'] ??= 3306;
$config['timeout'] ??= 30;

var_dump($config);
// Output:
// array(3) {
//   ["host"]=> string(9) "localhost"
//   ["port"]=> int(3306)
//   ["timeout"]=> int(30)
// }

Match Expression vs Switch (PHP 8.0)

PHP 8.0 introduced the match expression as a more powerful and concise alternative to the traditional switch statement. Unlike switch, match is an expression (it returns a value) and uses strict comparison (===) instead of loose comparison (==). This eliminates common bugs where type juggling causes unexpected matches.

Key Differences: - match returns a value; switch does not. - match uses strict comparison; switch uses loose comparison. - match can combine multiple conditions with a comma; switch requires fall-through or break. - match throws an UnhandledMatchError if no arm matches (unless a default is provided); switch silently continues.

Example:

```php $statusCode = 404;

// Switch (loose comparison) switch ($statusCode) { case 200: case 302: $message = 'OK'; break; case 404: $message = 'Not Found'; break; case 500: $message = 'Server Error'; break; default: $message = 'Unknown'; }

// Match (strict comparison) $message = match ($statusCode) { 200, 302 => 'OK', 404 => 'Not Found', 500 => 'Server Error', default => 'Unknown', }; ```

Notice how match is more concise and eliminates the need for break statements. It also forces you to handle all cases explicitly (or provide a default), reducing bugs from forgotten cases.

When to use each: - Use match when you need to return a value and want strict comparison. - Use switch when you need side effects (like multiple statements per case) or when loose comparison is intentional.

match is generally preferred for new code due to its safety and readability.

<?php

$statusCode = '404'; // string

// Switch: loose comparison, so '404' == 404 is true
switch ($statusCode) {
    case 404:
        echo 'Switch: Not Found';
        break;
    default:
        echo 'Switch: Unknown';
}
// Output: Switch: Not Found

// Match: strict comparison, so '404' === 404 is false
$message = match ($statusCode) {
    404 => 'Match: Not Found',
    default => 'Match: Unknown',
};
echo $message;
// Output: Match: Unknown