Control Flow — if, match, loops

The mental model

Control flow is just decisions and repetition. Every program is a sequence of "do this, then if X do this, otherwise do that, then repeat for each item in the list." That's it. The syntax in each language is different but the shapes are the same everywhere. You're already doing this in your head — "if the dishwasher is full, run it, otherwise add more dishes." Programming is just writing those decisions down so a computer can follow them.

if / elseif / else

The classic. Pick one branch based on conditions:

if ($score >= 90) {
    $grade = 'A';
} elseif ($score >= 75) {
    $grade = 'B';
} elseif ($score >= 50) {
    $grade = 'C';
} else {
    $grade = 'F';
}

Two small things worth noting. elseif is one word in PHP. The two-word else if also works but it's less idiomatic — pick one style and stick with it, doesn't really matter which. Second, you'll sometimes see the alternate "colon syntax" for templates:

<?php if ($logged_in): ?>
  <a href="/logout">Sign out</a>
<?php else: ?>
  <a href="/login">Sign in</a>
<?php endif; ?>

That's the same as if/else, just with endif; instead of curly braces. When you're mixing PHP and HTML, this form is way more readable because you can clearly see where the PHP control flow ends. We saw the same pattern with foreach in chapter 1.

Ternary and null coalescing

The ternary operator is a one-line shorthand for if/else that returns a value:

$label = $is_admin ? 'Admin' : 'User';

Read it as: "if $is_admin is truthy, $label = 'Admin'; otherwise $label = 'User'." Same logic as a four-line if/else, but on one line. Great for simple assignments. PHP has a few more compact variants of this idea:

// Short ternary — returns left if truthy, else right
$display = $name ?: 'Anonymous';

// Null coalescing — returns left if SET and not null
$name = $_GET['name'] ?? 'guest';

// Null coalescing assignment — assign default if null
$cache['key'] ??= compute_expensive_value();

The differences are subtle but important. The short ternary ?: uses the left value if it's truthy. So 0 ?: 'fallback' returns 'fallback' because 0 is falsy. The null coalescing ?? uses the left value if it's set and not null. So 0 ?? 'fallback' returns 0, because 0 is not null. The distinction matters more than you'd think — using ?: on a number field will treat 0 as "missing" when it's actually a real input. Default to ?? for "is this missing" checks.

One rule for keeping your sanity: don't nest ternaries. $a ? $b : ($c ? $d : $e) is hard to read; pyramids of ternaries are unreadable. If you're reaching for a triple-nested ternary, just write a proper if/else. Your teammates (including future-you) will love you for it.

match — the modern switch (PHP 8+)

Switch statements have been a C-family staple forever, but they have some warts — fall-through behavior, loose comparison, no value return. PHP 8 added a new match expression that fixes all of that. For value-mapping (turning one value into another), match is just better:

$color = match ($status) {
    'pending', 'review' => 'yellow',
    'done'              => 'green',
    default             => 'grey',
};

Why match beats switch on every front:

• It returns a value — you can assign the whole expression directly. No need for break or manual assignment in each case.
• It uses === (strict equality) — no sneaky type coercion.
• No fall-through — each arm is independent. Group multiple cases by listing them together ('pending', 'review').
• Throws if nothing matches — if there's no default and the value doesn't match any case, you get an UnhandledMatchError. This forces you to handle every possibility, which is usually exactly what you want.

Whenever you need to map one value to another value, use match. The classic switch is still useful for "do different things in each branch" (function calls, side effects), but for value mapping, match wins.

🐍 Python: Almost identical to Python 3.10's match statement. Same keyword, same shape. PHP actually got there first by a year. Python's match supports deeper structural patterns; PHP's is simpler but covers the 90% case.

Loops — for, while, foreach

Three classic loop shapes plus PHP's beloved foreach. Each has its sweet spot:

// for — when you know the count
for ($i = 0; $i < 10; $i++) { echo $i; }

// while — when condition is the focus
$i = 0;
while ($i < 10) { echo $i++; }

// do-while — when the body must run at least once
do {
    $line = read_input();
} while ($line !== '');

// foreach — the workhorse (you'll use this 90% of the time)
foreach ($tags as $tag) {
    echo $tag;
}

foreach ($user as $key => $value) {
    echo "$key: $value\n";
}

Quick rule of thumb on choosing: for when the count matters and you have a clear start/end/step. while when the condition is the main focus and the loop might run indefinitely until something changes. do-while when the body has to run at least once before you can check the condition (reading input, polling). And foreach for everything else — iterating arrays is by far the most common loop you'll write.

break and continue

Two keywords for jumping around inside a loop:

foreach ($items as $item) {
    if ($item->archived) continue;   // skip this iteration
    if ($item->poison)   break;      // exit the loop entirely
    process($item);
}

continue means "skip the rest of this iteration and start the next one." break means "exit the loop entirely." Both can take an optional integer to break/continue out of nested loops: break 2; exits two levels. Occasionally useful. If you find yourself writing break 3, that's a sign your function should probably be split up into smaller pieces.

Early returns beat deep nesting

This is a universal coding rule but worth saying loud here because it makes a massive difference in how readable your code is. When you have a function that has several "if this is bad, bail" checks, the temptation is to nest them. Resist. Bail out at the top, leave the happy path flat.

Compare these two versions of the same function. They do exactly the same thing:

// Flat (early returns) — winner
function process(?User $u): string {
    if ($u === null)        return 'no user';
    if (!$u->is_active())   return 'inactive';
    if ($u->is_banned())    return 'banned';

    // happy path is flat and easy to follow
    return do_the_thing($u);
}

// Nested — harder to read
function process(?User $u): string {
    if ($u !== null) {
        if ($u->is_active()) {
            if (!$u->is_banned()) {
                return do_the_thing($u);
            } else {
                return 'banned';
            }
        } else {
            return 'inactive';
        }
    } else {
        return 'no user';
    }
}

The first version reads top-to-bottom like a story: "first check this, then check that, then do the work." The second forces you to hold three levels of nested context in your head while you read. Flat reads better, every single time. It's like reading a recipe vs reading a flowchart — recipes win for sequential work.