PHP Conditionals and Control Flow

PHP control flow decides which statements run and how often they repeat. Conditionals choose a branch, while loops repeat a block until the data or condition says to stop.

For example, an account form might reject an invalid email address, choose a welcome message, and loop through the fields that need checking. These examples build on the basics in our PHP guide.

Use strict comparisons for application decisions unless type conversion is deliberate. Keep branches large enough to read, stop switch cases explicitly, and make every loop's exit condition easy to identify.

How Do PHP Conditions Compare Values?

A PHP condition evaluates an expression as true or false. The expression may compare values, read a boolean, call a function, or combine conditions with && and ||.

<?php

$age = 19;
$country = "AU";

if ($age >= 18 && $country === "AU") {
    echo "Adult account";
}

The condition passes only when the age is at least 18 and the country is AU. Strict identity checks both type and value; loose equality may convert types first:

<?php

$input = "0";

var_dump($input == 0);  // true
var_dump($input === 0); // false

Submitted form input normally reaches PHP as strings. Validate and convert it before the branch so the condition compares the application value you intended:

<?php

$quantity = filter_input(
    INPUT_POST,
    "quantity",
    FILTER_VALIDATE_INT,
);

if ($quantity === null || $quantity === false || $quantity < 1) {
    throw new InvalidArgumentException(
        "Quantity must be a positive integer",
    );
}

Build a Conditional Chain Step by Step

Start with one branch for the invalid state. This version rejects an empty order and leaves every positive total on the normal path:

<?php

if ($orderTotalCents <= 0) {
    $status = "empty";
}

Add elseif when another condition needs a different result, then use else for the remaining valid values:

<?php

if ($orderTotalCents <= 0) {
    $status = "empty";
} elseif ($orderTotalCents < 5000) {
    $status = "small";
} else {
    $status = "standard";
}

The order of conditions matters because PHP stops after the first true branch. Put the narrow invalid or exceptional cases first, then let the ordinary path continue.

Guard clauses use the same pattern at a function boundary. In this illustration, userCanPublish() and markArticlePublished() are application functions you must provide:

<?php

function publishArticle(array $article, int $userId): void
{
    if (! userCanPublish($userId)) {
        throw new RuntimeException(
            "User cannot publish articles",
        );
    }

    if (($article["title"] ?? "") === "") {
        throw new InvalidArgumentException(
            "Article title is required",
        );
    }

    markArticlePublished($article);
}

The permission and title failures leave early, so the final write remains on a shallow, visible path. This shape helps reviewers confirm that authorization happens before the data change.

When Should You Use PHP match?

Use PHP match when one value selects a result, such as a display label for a status. Available since PHP 8.0, match compares both value and type:

<?php

$label = match ($status) {
    "draft" => "Draft",
    "review" => "In review",
    "published" => "Published",
    default => "Unknown",
};

The same status can select a CSS class instead of a label:

<?php

$cssClass = match ($status) {
    "draft" => "status-draft",
    "review" => "status-review",
    "published" => "status-published",
    default => "status-unknown",
};

match uses ===, returns a value, never falls through, and must be exhaustive. If the set is meant to be closed, omitting default lets an unexpected state throw UnhandledMatchError during testing instead of hiding it under a generic label.

When Should You Use PHP switch?

PHP switch is useful when one value selects a block of statements rather than one returned value. The handlers and article ID below are application-provided examples:

<?php

switch ($requestMethod) {
    case "GET":
        showArticle($articleId);
        break;

    case "POST":
        updateArticle($articleId);
        break;

    default:
        http_response_code(405);
        echo "Method not allowed";
        break;
}

switch compares loosely and continues into the next case unless break, return, or throw stops it. Deliberate fallthrough can group labels, but a short comment should explain why the cases share code.

Which PHP Loop Should You Use?

Use PHP foreach for array items, for for a counter, and while when a condition controls repetition. A do...while loop checks its condition after the body, so it always runs at least once.

Loop Over a PHP Array

Start with the values when the array keys do not matter:

<?php

$statuses = ["draft", "review", "published"];

foreach ($statuses as $status) {
    echo $status, PHP_EOL;
}

The loop prints each status on its own line:

draft
review
published

Add the key when the output needs both the position and the value:

<?php

foreach ($statuses as $position => $status) {
    echo $position + 1, ": ", $status, PHP_EOL;
}

foreach advances through the array for you. Use a reference only when the loop must modify the original values, then call unset() on the reference variable after the loop to avoid carrying it into later code.

Repeat Until a Condition Changes

A while loop fits a queue whose length changes as each item is handled:

<?php

$jobs = ["resize-image", "send-email", "build-report"];

while ($jobs !== []) {
    $job = array_shift($jobs);
    echo "Processing: ", $job, PHP_EOL;
}

Each pass removes one job, so the queue eventually becomes empty and the condition becomes false. When the loop body cannot change the exit condition, the code can run until a timeout or manual stop.

Check Input and Permissions Before Changing Data

PHP applications should check input and permissions before changing data. For example, reject an invalid form value before saving it, and confirm that a user can edit an article before updating its database row.

PHP security fundamentals uses branches around sessions, CSRF, uploads, and output. PHP and MySQL with PDO branches around query results and failed writes. Building a small PHP database app connects those checks across a complete request.

Common Pitfalls & Debugging

Loose Comparison Accepts the Wrong Value

Symptom: a string from a form matches a numeric condition unexpectedly. Cause: == converted one operand before comparing. Fix: validate and convert the input first, then use === or another strict comparison against the expected type.

Switch and Match Handle Types Differently

Symptom: code moved from switch to match stops recognizing a value such as string "1" against integer 1. Cause: switch uses loose equality while match uses identity. Fix: normalize the subject to one documented type before branching and cover every expected arm.

A Loop Never Reaches Its Exit

Symptom: a request hangs or reaches its execution-time limit. Cause: the loop body never changes the condition that keeps the loop running. Fix: identify the exit condition in plain language, update it on every intended path, and add a bounded counter when external data can keep arriving.

Frequently Asked Questions

When should you use if instead of match in PHP?

In PHP, use if when branches depend on different boolean expressions, ranges, permissions, validation results, or several values at once. Use match when one subject value must select and return a result from a known set of strictly compared alternatives.

Can PHP match test several different conditions?

PHP match can test different conditions by using true as its subject and boolean expressions as its arms. Each condition is compared strictly with true. Include a default arm unless the conditions cover every possible case.

Does PHP match evaluate every arm or stop at the first match?

PHP match checks conditions in order and evaluates the result expression of the first matching arm. Later conditions and the result expressions of unselected arms are not evaluated.

Which loop should you use for a PHP array?

Use PHP foreach for most arrays because it gives each key and value directly without a separate counter. Use for when the numeric position controls the work, and use while when repetition should continue until a condition changes.

Why should you unset a PHP foreach reference after the loop?

A PHP foreach loop by reference leaves its loop variable linked to the last element it visited. Reusing that variable can accidentally change the array. Call unset() on the variable immediately after the loop to remove the reference.