🔀 PHP Control Structures and Functions

Why Control Flow Matters

Control structures are the decision-makers and traffic directors of a program. They decide which statements run, when they run, and how many times they run.

💡 Analogy: Control structures are the traffic signals of your code. Without them, every line runs once, top to bottom, no matter what. With them, your program can react — showing one page to a logged-in user and another to a guest, or looping over a thousand products to build a page.

Functions then let you take a useful chunk of that logic, give it a name, and call it from anywhere — the foundation of code you can maintain instead of copy-paste.

Conditional Statements

Conditionals run a block only when a condition is true. They are the forks in the road of your program.

if / elseif / else

<?php
$score = 85;

if ($score >= 90) {
    $grade = "A";
} elseif ($score >= 80) {
    $grade = "B";
} elseif ($score >= 70) {
    $grade = "C";
} elseif ($score >= 60) {
    $grade = "D";
} else {
    $grade = "F";
}

echo "Your grade is {$grade}";   // Your grade is B

PHP evaluates each condition in order and stops at the first one that is true. The diagram below traces that grading logic:

Ternary & null coalescing

For a simple two-way choice, the ternary operator is compact and readable:

<?php
$age    = 20;
$status = ($age >= 18) ? "adult" : "minor";

// The "Elvis" shorthand returns the left side if it is truthy:
$name = $input ?: "Anonymous";

// Null coalescing supplies a default for missing/undefined values:
$username = $_GET['user'] ?? "Guest";

switch vs match

When you compare one value against many possibilities, switch is cleaner than a long if chain:

<?php
$day = date("l");   // e.g. "Monday"

switch ($day) {
    case "Saturday":
    case "Sunday":
        $message = "Weekend!";
        break;
    case "Friday":
        $message = "Almost there.";
        break;
    default:
        $message = "A working day.";
        break;
}

Each case needs a break, or execution "falls through" to the next case — occasionally useful (as with Saturday/Sunday above) but a frequent source of bugs.

The modern match expression (PHP 8+)

match fixes switch's rough edges: it uses strict comparison (===), needs no break, and returns a value you can assign directly.

<?php
$day = date("l");

$message = match ($day) {
    "Saturday", "Sunday" => "Weekend!",
    "Friday"             => "Almost there.",
    default              => "A working day.",
};

echo $message;

Looping Structures

Loops execute a block repeatedly — like an assembly line processing items until the job is done. PHP offers four.

while and do-while

<?php
// while: checks BEFORE each pass — may run zero times
$counter = 1;
while ($counter <= 3) {
    echo "Pass {$counter}\n";
    $counter++;
}

// do-while: checks AFTER each pass — always runs at least once
$n = 10;
do {
    echo "n is {$n}\n";
    $n++;
} while ($n < 3);   // runs once even though 10 < 3 is false

for

Use for when you know the number of iterations up front. Its header bundles the initializer, condition, and step:

<?php
for ($i = 1; $i <= 5; $i++) {
    echo "Iteration {$i}\n";
}

foreach — the workhorse

foreach is purpose-built for arrays and is the loop you'll use most in web code:

<?php
$fruits = ["apple", "banana", "cherry"];
foreach ($fruits as $fruit) {
    echo "I like {$fruit}\n";
}

// Access keys and values of an associative array:
$person = ["name" => "Ada", "role" => "Engineer"];
foreach ($person as $key => $value) {
    echo "{$key}: {$value}\n";
}

break and continue

<?php
foreach ($orders as $order) {
    if ($order['status'] === 'cancelled') {
        continue;             // skip this one, keep looping
    }
    if ($order['total'] > 10000) {
        echo "Big order found!\n";
        break;                // stop the loop entirely
    }
    processOrder($order);
}

continue jumps to the next iteration; break exits the loop completely.

Defining Functions

A function is a named, reusable block of code. Think of functions as labelled tools in a workshop — each does one job well, so you don't rebuild it every time.

Parameters, defaults, and return types

Modern PHP lets you annotate parameter and return types, which document intent and catch mistakes early:

<?php
function calculateArea(float $length, float $width): float {
    return $length * $width;
}

echo calculateArea(5, 3);   // 15

// A default value makes a parameter optional:
function greet(string $name, string $time = "day"): string {
    return "Good {$time}, {$name}!";
}

echo greet("Alice");             // Good day, Alice!
echo greet("Bob", "evening");    // Good evening, Bob!

<?php
echo greet(name: "Cleo", time: "morning");

Returning early

A function ends as soon as it hits a return. Returning early for the "bad" cases keeps the happy path flat and readable:

<?php
function priceWithTax(?float $price): ?float {
    if ($price === null || $price < 0) {
        return null;            // guard clause
    }
    return round($price * 1.08, 2);
}

The ?float type means "a float or null" — a nullable type, useful for values that might be absent.

Scope, Closures & Arrow Functions

Variables created inside a function are local to it — invisible outside, and vice versa. This isolation is a feature: it stops functions from stepping on each other's data.

<?php
$message = "outside";

function show(): void {
    // echo $message;   // ERROR: $message is not visible here
    $message = "inside";
    echo $message;      // "inside"
}

show();
echo $message;          // still "outside"

Closures

An anonymous function (closure) has no name and can be stored in a variable or passed to other functions. Use use to capture outer variables explicitly:

<?php
$tax = 0.08;

$addTax = function (float $amount) use ($tax): float {
    return $amount + $amount * $tax;
};

echo $addTax(100);   // 108

Arrow functions (PHP 7.4+)

Arrow functions are a terse form for one-expression closures. They capture outer variables automatically — no use needed — which shines with array helpers:

<?php
$numbers = [1, 2, 3, 4, 5];

$doubled = array_map(fn($n) => $n * 2, $numbers);
// [2, 4, 6, 8, 10]

$evens = array_filter($numbers, fn($n) => $n % 2 === 0);
// [2, 4]

Best Practices

Compare the two versions below — the second reads top to bottom with no pyramid of braces:

<?php
// Deeply nested — hard to follow
function processOrder(array $order): bool {
    if ($order) {
        if ($order['status'] === 'pending') {
            if ($order['paid']) {
                return true;
            }
        }
    }
    return false;
}

// Guard clauses — flat and clear
function processOrder(array $order): bool {
    if (!$order)                          return false;
    if ($order['status'] !== 'pending')   return false;
    if (!$order['paid'])                  return false;
    return true;
}

Hands-on Exercise

<?php
function gradeFor(int $score): string {
    return match (true) {
        $score >= 90 => "A",
        $score >= 80 => "B",
        $score >= 70 => "C",
        $score >= 60 => "D",
        default      => "F",
    };
}

$students = [
    "Ada"   => 91,
    "Bpel"  => 74,
    "Cleo"  => 58,
    "Devi"  => 83,
];

$total = 0;
foreach ($students as $name => $score) {
    $total += $score;
    echo "{$name}: {$score} → " . gradeFor($score) . "\n";
}

$average = $total / count($students);
echo "Class average: " . number_format($average, 1) . "\n";

/*
Ada: 91 → A
Bpel: 74 → C
Cleo: 58 → F
Devi: 83 → B
Class average: 76.5
*/

Summary & Quiz

📚 Further Reading

• PHP Manual — Control Structures
• PHP Manual — match
• PHP Manual — Functions
• PHP: The Right Way

🚀 What's Next?

You can now hold data, make decisions, and package logic. Next, Embedding PHP in HTML shows how to weave all of this directly into web pages to produce dynamic output.