Control Statements (Part 2)

PHP Control Statements (Part 2)

return, exit(), die(), and goto

Introduction

In Part 1, you learned how break and continue control the execution of loops.

In this lesson, we'll explore four more control statements:

• return
• exit()
• die()
• goto

Among these, return is one of the most frequently used statements in professional PHP development.

Whether you're building Laravel applications, REST APIs, WordPress plugins, or custom PHP projects, you'll use return every day.

On the other hand, exit(), die(), and goto are much less common. Understanding when—and when not—to use them is an important part of becoming a professional PHP developer.

The return Statement

The return statement immediately stops the execution of a function and optionally sends a value back to the caller.

Think of a function as a machine. You provide an input. The machine processes the input. Then it returns the result.

Without return, the function performs its work but doesn't send anything back.

Basic Syntax

return;

return $value;

Example 1: Returning a Number

<?php

function add($a, $b)
{
    return $a + $b;
}

$total = add(20, 30);

echo $total;

Output: 50

Example 2: Returning a String

<?php

function greet($name)
{
    return "Welcome " . $name;
}

echo greet("John");

Output: Welcome John

Example 3: Returning a Boolean

<?php

function isAdult($age)
{
    return $age >= 18;
}

if (isAdult(25)) {
    echo "Eligible";
}

Output: Eligible — returning a boolean is very common in validation methods.

Returning Arrays

<?php

function getColors()
{
    return ["Red", "Green", "Blue"];
}

$colors = getColors();

print_r($colors);

Returning Associative Arrays

<?php

function getUser()
{
    return [
        "name" => "Rahul",
        "role" => "Admin",
        "active" => true
    ];
}

$user = getUser();

echo $user["name"];

Output: Rahul — frequently used in APIs and database operations.

Early Return

One of the best programming practices is using Early Return.

Poor approach:

<?php

function processOrder($order)
{
    if ($order != null) {

        if ($order["paid"]) {

            echo "Processing...";
        }
    }
}

Better approach:

<?php

function processOrder($order)
{
    if ($order == null) {
        return;
    }

    if (!$order["paid"]) {
        return;
    }

    echo "Processing...";
}

Easier to read, maintain, and debug. Professional developers prefer early returns because they reduce unnecessary nesting.

Multiple Return Statements

<?php

function checkNumber($number)
{
    if ($number > 0) {
        return "Positive";
    }

    if ($number < 0) {
        return "Negative";
    }

    return "Zero";
}

echo checkNumber(-5);

Output: Negative

Code After return

<?php

function demo()
{
    return "Finished";

    echo "This line never executes.";
}

echo demo();

Output: Finished — everything after return in the same function is unreachable.

Real-World Example: User Authentication

<?php

function login($username, $password)
{
    if (empty($username)) {
        return "Username Required";
    }

    if (empty($password)) {
        return "Password Required";
    }

    return "Login Successful";
}

echo login("admin", "secret");

Output: Login Successful

Real-World Example: API Response

<?php

function getResponse($success)
{
    if (!$success) {
        return [
            "status" => 500,
            "message" => "Server Error"
        ];
    }

    return [
        "status" => 200,
        "message" => "Success"
    ];
}

Returning structured arrays is a common practice before converting them to JSON.

The exit() Function

Sometimes you want to stop the entire PHP script immediately. That's exactly what exit() does.

exit();

Everything after exit() is ignored.

exit() Example

<?php

echo "Start";

exit();

echo "End";

Output: Start

Returning a Message

exit("Application Closed");

Output: Application Closed

Real-World Example: Maintenance Mode

<?php

$maintenance = true;

if ($maintenance) {
    exit("Website Under Maintenance.");
}

echo "Welcome";

When Should You Use exit()?

Use exit() when:

• The application cannot continue safely.
• A critical configuration is missing.
• The system enters maintenance mode.
• You intentionally stop a command-line script after a fatal condition.

Avoid scattering exit() throughout business logic, as it makes testing and reuse more difficult.

The die() Function

die() behaves exactly like exit().

die("Fatal Error");

Internally, die() is simply an alias of exit(). Choose one style and use it consistently within your project.

die() Real-World Example

<?php

$file = "config.php";

if (!file_exists($file)) {
    die("Configuration File Missing");
}

exit() vs die()

The goto Statement

PHP also supports the goto statement. It allows execution to jump directly to a labeled section of code.

goto label;

label:

goto Example

<?php

echo "Start";

goto end;

echo "This line is skipped.";

end:

echo "Finished";

Output: StartFinished

Should You Use goto?

Almost never. Professional developers prefer functions, loops, conditionals, exceptions, and early returns.

Why goto Is Discouraged

In large applications, random jumps create spaghetti code — hard to trace which code executes, which is skipped, and where execution came from.

Real-World Scenario: Payment Processing

<?php

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

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

    return "Payment Successful";
}

echo processPayment(5000);

Using early return statements keeps the logic straightforward. There is no need for goto.

Real-World Scenario: File Upload Validation

<?php

function uploadFile($file)
{
    if (empty($file)) {
        return "No File Selected";
    }

    if ($file["size"] > 5000000) {
        return "File Too Large";
    }

    return "Upload Successful";
}

Performance Considerations

The biggest benefit isn't raw speed — it's avoiding unnecessary work: stop searching after finding a product, skip invalid CSV rows, return after failed validation, prevent expensive queries when input is invalid.

Best Practices

• Prefer early return over deeply nested if statements.
• Return meaningful values from functions.
• Keep functions focused on a single responsibility.
• Use exit() only when the application truly cannot continue.
• Avoid goto in production code.
• Write code that other developers can understand easily.

Common Mistakes

• Forgetting that return ends the function — code after return never runs.
• Using exit() in reusable functions — return an error and let the caller decide.
• Overusing goto — creates confusing control flow.
• Inconsistent return types — aim for a clear contract per function.

Summary

• Use return to exit a function and optionally send a value back.
• Use exit() or die() to stop the entire script when continuing is unsafe.
• Avoid goto — functions, loops, and early returns are clearer.

Mastering these statements will help you write cleaner, more reliable PHP applications and prepare you for real-world development with frameworks like Laravel, Symfony, and CodeIgniter.

What's Next?

In Control Statements (Part 3), you'll apply everything in a hands-on project, review best practices, and work through professional interview questions.

Continue at /learn/php/control-statements-part-3.