Functions

A function is a named unit of behavior. It accepts input, performs one defined job, and can return a result to the code that called it.

Functions are not only a way to avoid duplicated lines. A useful function gives a rule a name and a boundary. calculateTaxCents() communicates more than the multiplication inside it, and formatCustomerName() tells a reader why trimming and joining text are happening.

Use a function when a piece of logic has a clear purpose, is called more than once, needs focused testing, or would make the surrounding script easier to read.

Declare And Call A Function

A named function starts with function, followed by its name, parameter list, optional return type, and body:

<?php

function formatFullName(string $firstName, string $lastName): string
{
    $cleanFirstName = trim($firstName);
    $cleanLastName = trim($lastName);

    return "$cleanFirstName $cleanLastName";
}

$fullName = formatFullName(' Ada ', ' Lovelace ');

echo $fullName, PHP_EOL;

Output:

Ada Lovelace

Declaring the function defines the behavior. Calling formatFullName(...) runs it. Parentheses are required for the call, even when a function has no parameters.

Execution enters the function with values assigned to its parameters. When PHP reaches return, execution leaves the function and the returned value replaces the call expression. In the example, the returned string becomes the value assigned to $fullName.

Parameters And Arguments Are Different

Parameters are the input names in the declaration:

function formatFullName(string $firstName, string $lastName): string

Arguments are the values supplied by a particular call:

formatFullName('Ada', 'Lovelace');

Here, $firstName and $lastName are parameters. 'Ada' and 'Lovelace' are arguments.

That distinction matters when debugging. "The $lastName parameter expects a string" describes the function contract. "The second argument was 'Lovelace'" describes one call.

By default, ordinary arguments are passed by value. A function works with its parameter value without changing the caller's variable:

<?php

function normaliseCode(string $code): string
{
    $code = strtoupper(trim($code));

    return $code;
}

$code = ' ab-12 ';
$normalisedCode = normaliseCode($code);

var_dump($code);
var_dump($normalisedCode);

Output:

string(7) " ab-12 "
string(5) "AB-12"

PHP also supports pass-by-reference parameters, but they create an intentional mutation of caller-owned data. They are deferred until references are covered explicitly. Returning a transformed value is clearer for most beginner functions.

A Signature Describes The Contract

This signature says the function requires two strings and promises a string result:

function formatFullName(string $firstName, string $lastName): string

Parameter names should describe meaning, not merely type. $subtotalCents is better than $number because it records both purpose and unit. $ratePercent is clearer than $rate when callers must pass 20 rather than 0.20.

Basic parameter and return declarations make examples easier to understand and help PHP and development tools detect mismatched values. A later lesson covers coercion, nullable types, void, unions, and strict_types in detail. For now, make simple function contracts visible.

Return A Value Instead Of Printing It

A calculation or formatter should usually return its result:

<?php

function formatPrice(int $cents): string
{
    return 'GBP ' . number_format($cents / 100, 2);
}

$basketLabel = formatPrice(1299);
$emailLabel = formatPrice(1299);

echo "Basket: $basketLabel\n";
echo "Email: $emailLabel\n";

formatPrice() decides how a price looks. It does not decide whether that text belongs in a command-line message, an HTML page, an email, or a test assertion.

A function that echoes directly combines calculation with output. Sometimes output is the function's actual job, but business rules and formatting functions are more reusable when the caller controls the destination.

Do not confuse return with echo:

• return sends a value to the caller and leaves the function;
• echo writes output and then execution continues;
• assigning a function call stores its returned value;
• ignoring a return value discards it.

return Ends The Current Function Call

Statements after an executed return are unreachable:

<?php

function shippingMessage(bool $isPaid): string
{
    if (!$isPaid) {
        return 'Waiting for payment';
    }

    return 'Ready to ship';
}

echo shippingMessage(false), PHP_EOL;

The first return handles the unpaid path immediately. If $isPaid is true, that branch is skipped and execution reaches the second return.

This early-return pattern is useful when one condition prevents the main result. Each possible path must still return the type promised by the signature. A function declared : string should not accidentally reach its closing brace without returning a string.

Exceptions provide another way for a function to stop when it cannot complete its contract, but throwing and catching them belongs to the later errors and exceptions lesson.

Use Default Values For Genuinely Optional Input

A default value lets a caller omit an optional argument:

<?php

function buildGreeting(string $name, string $prefix = 'Hello'): string
{
    return "$prefix, $name";
}

echo buildGreeting('Mina'), PHP_EOL;
echo buildGreeting('Mina', 'Welcome back'), PHP_EOL;

Output:

Hello, Mina
Welcome back, Mina

The default is used only when the argument is omitted. Passing another value replaces it. Passing null does not mean "use the default" and would not satisfy this parameter's string declaration.

Put required parameters before optional parameters:

function buildGreeting(string $name, string $prefix = 'Hello'): string

Putting a required parameter after one with a default prevents that earlier argument from being omitted positionally. In common forms, PHP treats the supposedly optional parameter as required and deprecates the declaration. Keep signatures ordered from required inputs to optional choices.

Defaults should represent unsurprising convenience, not a hidden business decision. A default greeting prefix is visible and low risk. A silently selected tax jurisdiction or permission level would deserve an explicit argument.

Positional And Named Arguments

The calls so far use argument position:

buildGreeting('Mina', 'Welcome back');

PHP 8 and later also support named arguments:

buildGreeting(name: 'Mina', prefix: 'Welcome back');

Named arguments can make calls with several similar values easier to read, and they can skip optional parameters. Positional arguments must come before named arguments when both styles are combined.

Use named arguments deliberately. Parameter names become part of how callers invoke the function, so renaming a public parameter can break named calls even when the value types and order stay the same. For short project-local calls, positional arguments are often sufficient.

Compose Small Functions

One function can use another function's returned value:

<?php

function calculateTaxCents(int $subtotalCents, int $ratePercent): int
{
    return (int) round($subtotalCents * $ratePercent / 100);
}

function calculateTotalCents(int $subtotalCents, int $ratePercent): int
{
    $taxCents = calculateTaxCents($subtotalCents, $ratePercent);

    return $subtotalCents + $taxCents;
}

echo calculateTotalCents(2500, 20), PHP_EOL;

Output:

3000

calculateTotalCents() delegates one named rule rather than repeating the tax formula. This is useful when the extracted function represents a real concept and can be tested independently.

Do not split every operator into a separate function. Extraction should improve the vocabulary or remove meaningful duplication, not force a reader to jump through many files to understand one line.

Keep One Clear Responsibility

A focused function should be explainable with one short sentence:

• formatFullName() cleans and joins two name parts;
• calculateTaxCents() calculates tax in cents;
• isPaidOrder() answers one yes-or-no question.

A function that validates a form, saves a database row, sends an email, and prints HTML has several reasons to change. It is difficult to reuse and difficult to verify without triggering all of its effects.

At this stage, prefer functions that calculate, classify, or format and then return a result. These are predictable: the same arguments produce the same result, and the caller can inspect the return value directly.

Name Functions For Their Result Or Action

Use a verb that reveals the job:

• formatPrice() returns formatted text;
• calculateTotalCents() returns a calculation;
• isEligibleForDiscount() returns a boolean decision;
• printReceipt() would perform output as its named action.

Avoid vague names such as process(), handleData(), doThing(), or runLogic(). They hide the rule a reader is trying to find.

Call functions with the same spelling and casing used in their declarations. PHP's ASCII function names are case-insensitive, but relying on that behavior makes searches and reviews less reliable. Also avoid declaring a name already used by another function in the same namespace; PHP cannot redeclare a function.

Test Boundaries, Not Only One Happy Example

A function call is easy to repeat with controlled values. For a shipping threshold function, useful checks include an amount below the threshold, exactly at it, and above it. For a formatter, try surrounding whitespace and already-clean input.

Write the expected result before running the code:

One passing example proves only one path. Boundary checks expose incorrect comparison operators, percentage conventions, rounding assumptions, and missing return paths.

Common Function Mistakes

What You Should Be Able To Do

After this lesson, you should be able to declare and call a named function, distinguish parameters from arguments, read a basic function signature as a contract, return a value to the caller, explain why return ends the current call, use an early return for a simple branch, put required parameters before defaults, recognise positional and named calls, compose small functions, choose names that reveal purpose and units, and test more than one input path.

The next lesson examines variable scope, globals, static variables, closures, and captured values. Error handling and detailed type behavior are covered separately so each boundary is introduced with enough context.

Official references: PHP's manual pages for user-defined functions, function parameters and arguments, and returning values.