PHP Functions — Parameter Order Change Breaks Checkout

Every real-world PHP application — from a login form to an e-commerce cart — is built on functions. They're the backbone of organised, maintainable code. Without them, you'd be writing the same logic over and over in dozens of places, and the moment something changes (a tax rate, a validation rule, a greeting message), you'd have to hunt down every copy and fix each one manually. That's where bugs are born.

Functions solve the 'write once, use everywhere' problem. You package a piece of logic into a named block, and then call that block by name whenever you need it. The code stays in one place, so a fix in one spot fixes it everywhere. This is one of the most fundamental ideas in all of programming, and PHP makes it beautifully simple to get started.

By the end of this article you'll know how to define your own PHP functions, pass data into them using parameters, get data back out using return values, set sensible defaults, and understand the difference between built-in and user-defined functions. You'll also walk away knowing the mistakes that trip up almost every beginner — and exactly how to dodge them.

What a PHP Function Actually Is (And Why You Need One)

A function is a named block of code that sits quietly until you call it. The moment you call it, PHP executes every line inside it, then hands control back to wherever you called it from.

PHP ships with hundreds of built-in functions — strlen() counts characters in a string, array_push() adds items to an array, date() formats a timestamp. You've been using other people's functions without even realising it.

But the real power is writing your own. Imagine you're building a website that greets every user by name. Without a function, you'd write that greeting logic on every page. With a function, you write it once, give it a name like greetUser(), and call that name wherever you need it.

This principle has a name: DRY — Don't Repeat Yourself. Functions are the primary tool for achieving it. They also make your code readable. A well-named function tells a future developer (or future you) exactly what a block of code does, without them having to read every line of it.

<?php

// Define the function using the 'function' keyword,
// followed by the name you choose, then parentheses.
function greetUser() {
    // Everything between the curly braces runs when the function is called.
    echo "Hello! Welcome to TheCodeForge." . PHP_EOL;
}

// The function does NOTHING until you call it by name.
// Call it once:
greetUser();

// Call it again — same result, zero extra code written.
greetUser();

// PHP's own built-in function for comparison:
$message = "Hello, World!";
$length  = strlen($message); // strlen is a built-in function — works the same way
echo "The message is " . $length . " characters long." . PHP_EOL;

?>

Passing Data Into Functions — Parameters and Arguments

A function with no input is useful, but a function that can accept data is powerful. This is where parameters come in.

A parameter is a variable you declare inside the function's parentheses. It acts as a placeholder — a slot waiting to receive a value. When you actually call the function and pass a value into that slot, that value is called an argument.

Here's the analogy: a parameter is like a labelled inbox on a desk ('place name here'). An argument is the actual piece of paper you drop into that inbox. The function then uses whatever you dropped in.

You can define multiple parameters by separating them with commas. The order matters — the first argument you pass maps to the first parameter, the second argument maps to the second parameter, and so on.

PHP also lets you define default parameter values. If the caller doesn't pass an argument, the parameter falls back to its default. This is incredibly handy for optional settings — think of it as a form field that's pre-filled but can be changed.

<?php

// A function with one parameter: $name
// $name is the PLACEHOLDER (parameter), not a real value yet.
function greetUserByName($name) {
    echo "Hey, " . $name . "! Great to see you." . PHP_EOL;
}

// We pass the actual value (argument) when calling the function.
greetUserByName("Alice");   // $name becomes "Alice" inside the function
greetUserByName("Bob");     // $name becomes "Bob" inside the function


// A function with TWO parameters.
function describeProduct($productName, $price) {
    echo $productName . " costs $" . $price . "." . PHP_EOL;
}

describeProduct("Wireless Keyboard", 49.99);
describeProduct("USB Hub", 19.99);


// DEFAULT PARAMETER VALUES
// If no currency is passed, it defaults to "USD".
function formatPrice($amount, $currency = "USD") {
    // The default only kicks in when the caller omits the argument.
    echo $currency . " " . number_format($amount, 2) . PHP_EOL;
}

formatPrice(1299.9);          // Uses default: USD
formatPrice(1299.9, "EUR");   // Overrides default: EUR

?>

Getting Data Back Out — Return Values

So far our functions print things directly. That's fine for simple output, but most of the time you want a function to calculate or process something and hand the result back to you so you can decide what to do with it next. That's what return does.

Think of return like a function handing you a receipt. You gave it your payment details (arguments), it processed the transaction (ran the logic), and now it's giving you something back (the return value) that you can hold onto, print, store in a variable, or pass into another function.

Once PHP hits a return statement, the function stops immediately. Anything after return in the same function is ignored. This makes return useful for early exits too — you'll see that pattern a lot in validation functions.

A function that doesn't have a return statement returns NULL by default. That's not an error, it just means the function produces no usable output beyond any side effects (like printing to the screen).

<?php

// This function CALCULATES a result and RETURNS it.
// It does NOT print anything — that's intentional.
function calculateDiscount($originalPrice, $discountPercent) {
    $discountAmount = $originalPrice * ($discountPercent / 100);
    $finalPrice     = $originalPrice - $discountAmount;

    return $finalPrice; // Hand the result back to whoever called us.
}

// We CAPTURE the return value in a variable.
$laptopPrice     = calculateDiscount(1200, 15); // 15% off $1200
$headphonesPrice = calculateDiscount(80, 10);   // 10% off $80

// Now we decide what to DO with those values.
echo "Laptop after discount: $" . number_format($laptopPrice, 2) . PHP_EOL;
echo "Headphones after discount: $" . number_format($headphonesPrice, 2) . PHP_EOL;

// You can also pass a return value directly into another function.
// Here we pass the return value of calculateDiscount() straight into number_format().
echo "Quick price: $" . number_format(calculateDiscount(500, 20), 2) . PHP_EOL;


// EARLY RETURN — stopping a function the moment something goes wrong.
function divideNumbers($numerator, $denominator) {
    if ($denominator === 0) {
        return "Error: Cannot divide by zero."; // Exit immediately.
    }

    return $numerator / $denominator; // Only runs if denominator is not zero.
}

echo divideNumbers(10, 2) . PHP_EOL;  // Works fine
echo divideNumbers(10, 0) . PHP_EOL;  // Caught early

?>

Variable Scope — Why Your Variables 'Disappear' Inside Functions

This is the concept that surprises almost every PHP beginner, so pay close attention. In PHP, variables defined outside a function are NOT automatically available inside it. Functions have their own private scope — like a room with a closed door.

If you create $username = 'Alice' at the top of your script and try to use $username inside a function without passing it in, PHP won't find it. The function's room has no window into the outside world by default.

There are three ways to get data into a function's scope: pass it as an argument (the recommended way), use the global keyword (rarely recommended, mostly a code smell), or use a closure with use() (an advanced topic). For now, stick to passing arguments — it makes your functions predictable and testable.

The reverse is also true: a variable you create inside a function disappears the moment the function finishes. It doesn't leak out into the rest of your script. This isolation is actually a feature, not a bug — it means functions can't accidentally overwrite your other variables.

<?php

$siteName    = "TheCodeForge";  // This lives in the GLOBAL scope.
$visitorCount = 4200;

function displaySiteInfo() {
    // PHP cannot see $siteName here — it's outside this function's scope.
    // Uncommenting the line below would print nothing (or a notice in strict mode):
    // echo $siteName;

    // This variable lives ONLY inside this function.
    $localMessage = "This message only exists inside displaySiteInfo()";
    echo $localMessage . PHP_EOL;
}

displaySiteInfo();

// $localMessage does NOT exist out here — it died when the function ended.
// echo $localMessage; // Would cause an 'Undefined variable' notice.


// THE RIGHT APPROACH: pass the data as arguments.
function displaySiteInfoCorrectly($siteName, $visitorCount) {
    // Now $siteName and $visitorCount exist in THIS function's scope
    // because we passed them in as arguments.
    echo $siteName . " has " . $visitorCount . " visitors this month." . PHP_EOL;
}

// We explicitly hand the outer variables INTO the function.
displaySiteInfoCorrectly($siteName, $visitorCount);


// THE global KEYWORD — know it exists, but use it sparingly.
$taxRate = 0.08;

function calculateTax($price) {
    global $taxRate; // Reach outside and grab $taxRate from global scope.
    return $price * $taxRate;
}

echo "Tax on $200: $" . calculateTax(200) . PHP_EOL;

?>

Type Declarations and Return Types – Writing Self-Documenting Functions

PHP 7+ and especially PHP 8 made it possible to declare the type of each parameter and the type of the return value. This isn't just documentation — it forces PHP to enforce the types at runtime, catching bugs before they reach production.

When you write function greet(string $name): string, you tell PHP: 'I expect a string as input, and I guarantee I'll return a string.' If someone passes an array or the function accidentally returns an integer, PHP throws a TypeError immediately.

Type declarations make your function contracts explicit. Anyone reading or using your function knows exactly what to pass and what to expect. Combined with strict mode (declare(strict_types=1);), even implicit type coercions are caught.

Common types include: int, float, string, bool, array, callable, iterable, object, and class/interface names. Union types (int|string) and nullable types (?int) give you even more flexibility.

<?php

declare(strict_types=1); // Enforce strict type checking

// Parameter type: int, return type: string
function formatAge(int $age): string {
    return "You are $age years old.";
}

// Union type — either int or float, return type: float
function applyTax(int|float $price, float $rate): float {
    return $price * (1 + $rate);
}

// Nullable parameter — ?string allows null or string
function greetOptional(?string $name): string {
    // If $name is null, replace with a default
    $name = $name ?? 'Guest';
    return "Hello, $name!";
}

// Usage
echo formatAge(30) . PHP_EOL;                    // Works
echo applyTax(100, 0.08) . PHP_EOL;             // Works: 108
// echo formatAge('thirty'); // TypeError if strict_types=1

echo greetOptional('Alice') . PHP_EOL;           // Hello, Alice!
echo greetOptional(null) . PHP_EOL;              // Hello, Guest!

?>