Control Statements (Part 3)

PHP Control Statements (Part 3)

Hands-on Project, Best Practices, Summary & Professional Interview Guide

Introduction

Welcome to the final part of this lesson.

So far, you've learned how to use:

• break
• continue
• return
• exit()
• die()
• goto

Now it's time to apply everything you've learned in practical scenarios, just like you would in a real software development project.

Hands-on Project

Project: Student Result Processing System

Imagine you're building a simple application for a school.

The application receives marks for multiple students and determines whether each student passed or failed.

Rules:

• Ignore students who were absent.
• Stop processing if corrupted data is found.
• Return the final report.

Let's build it step by step.

Step 1: Student Data

<?php

$students = [
    ["name" => "Rahul", "marks" => 85],
    ["name" => "Priya", "marks" => null],
    ["name" => "John", "marks" => 42],
    ["name" => "David", "marks" => -1],
    ["name" => "Riya", "marks" => 76]
];

Step 2: Processing Function

function processStudents($students)
{
    $report = [];

    foreach ($students as $student) {

        // Student absent
        if ($student["marks"] === null) {
            continue;
        }

        // Invalid data
        if ($student["marks"] < 0) {
            break;
        }

        $status = $student["marks"] >= 50 ? "Pass" : "Fail";

        $report[] = [
            "name" => $student["name"],
            "status" => $status
        ];
    }

    return $report;
}

Step 3: Display Results

$result = processStudents($students);

print_r($result);

Output:

Array
(
    [0] => Array
        (
            [name] => Rahul
            [status] => Pass
        )

    [1] => Array
        (
            [name] => John
            [status] => Fail
        )
)

Notice what happened.

• Priya was skipped using continue.
• David stopped processing using break.
• The function returned the processed report using return.

This small example combines three control statements in one practical solution.

Real-World Example 1 – CSV Import

Imagine importing 50,000 customer records.

foreach ($rows as $row) {

    if (empty($row["email"])) {
        continue;
    }

    if (!$databaseConnected) {
        break;
    }

    saveCustomer($row);
}

Why?

• Skip incomplete records.
• Stop immediately if the database becomes unavailable.

This prevents thousands of failed database operations.

Real-World Example 2 – Payment Gateway

function processPayment($amount)
{
    if ($amount <= 0) {
        return "Invalid Amount";
    }

    if ($amount > 100000) {
        return "Transaction Limit Exceeded";
    }

    return "Payment Successful";
}

Every validation returns immediately.

There is no unnecessary nesting.

This style is common in Laravel services and payment integrations.

Real-World Example 3 – REST API Validation

function createUser($request)
{
    if (empty($request["name"])) {
        return [
            "success" => false,
            "message" => "Name is required."
        ];
    }

    if (empty($request["email"])) {
        return [
            "success" => false,
            "message" => "Email is required."
        ];
    }

    return [
        "success" => true,
        "message" => "User created successfully."
    ];
}

Each validation exits early.

The code remains clean and easy to maintain.

Real-World Example 4 – Product Search

$products = ["Laptop", "Mouse", "Keyboard", "Monitor"];

foreach ($products as $product) {

    if ($product === "Keyboard") {
        echo "Found";
        break;
    }
}

Once the product is found, the search stops immediately.

Searching the remaining items would only waste time.

Real-World Example 5 – File Upload Validation

function validateFile($file)
{
    if ($file["size"] > 5000000) {
        return false;
    }

    if (!in_array($file["type"], ["image/jpeg", "image/png"])) {
        return false;
    }

    return true;
}

Returning early keeps validation simple and readable.

Best Practices

Prefer Early Returns

Instead of writing:

if (...) {
    if (...) {
        if (...) {
            // Logic
        }
    }
}

Write:

if (...) {
    return;
}

if (...) {
    return;
}

// Logic

Professional developers favor this style because it minimizes nesting and improves readability.

Use break Only When Necessary

Avoid breaking loops unless there is a clear reason.

Examples:

• Item found
• Error detected
• Required condition satisfied

Use continue to Skip Invalid Data

Do not terminate the entire loop because of one bad record. Skip it and continue processing whenever appropriate.

Keep Functions Small

Functions should perform one task.

If a function grows beyond 30–50 lines and contains many control statements, consider splitting it into smaller functions.

Avoid goto

Modern PHP frameworks almost never use goto.

Prefer:

• Functions
• Loops
• Exceptions
• Early returns

Write Self-Explanatory Code

Compare these:

if (!$user)
    return;

Versus:

if ($user === null) {
    return;
}

The second example is easier to understand and maintain.

Common Mistakes

Confusing break with continue

Wrong thinking: "I want to skip one record." Using:

break;

Correct:

continue;

break ends the loop. continue skips only the current iteration.

Writing Unreachable Code

return;

echo "Hello";

The echo statement will never execute. Always remove unreachable code.

Overusing exit()

Calling exit() inside helper functions makes code difficult to test and reuse. Instead, return an error and let the caller decide what to do.

Returning Inconsistent Data

Avoid writing functions like this:

return true;

return "Success";

return [];

return 100;

A function should ideally return a predictable type unless there is a compelling reason not to.

Deeply Nested Conditions

Bad:

if (...) {
    if (...) {
        if (...) {
            if (...) {
                // Code
            }
        }
    }
}

Better:

if (...) {
    return;
}

if (...) {
    return;
}

// Continue with business logic

Mini Challenge

Create a program that:

1. Reads an array of employee records.
2. Skips employees with missing email addresses.
3. Stops processing if a duplicate employee ID is detected.
4. Returns the list of valid employees.
5. Displays the final report.

Bonus Challenge

Modify the program to count:

• Processed employees
• Skipped employees
• Failed employees

Then display a summary at the end.

Summary

Control statements are essential tools for controlling how your PHP application executes.

Throughout this lesson, you learned:

• break stops a loop immediately.
• continue skips the current iteration and continues with the next.
• return exits a function and optionally returns a value.
• exit() and die() terminate the script.
• goto exists but is rarely appropriate in modern PHP.

These statements help you write code that is cleaner, more efficient, and easier to maintain.

When used thoughtfully, they improve readability, reduce unnecessary work, and make complex business logic easier to follow.

Key Takeaways

• Use break to end loops when no further processing is required.
• Use continue to ignore invalid or irrelevant data while keeping the loop running.
• Prefer early return statements to reduce nested conditions.
• Use return to provide meaningful results from functions.
• Reserve exit() and die() for situations where the application truly cannot continue.
• Avoid goto in production code.
• Keep functions focused, readable, and predictable.
• Consistent return types make APIs and functions easier to use.
• Readability is often more valuable than clever shortcuts.

Professional Interview Questions

Congratulations!

You have completed the PHP Control Statements lesson.

You now understand how professional PHP developers manage program flow using break, continue, return, exit(), die(), and goto. These concepts are fundamental to writing clean, maintainable, and production-ready PHP applications.

What's Next?

In Mastering the for Loop, you'll learn the for loop — the most commonly used loop in PHP for known iteration counts, nested patterns, and real-world data processing.

Continue at /learn/php/loops.