Functions in PHP - how to use with complete example

If you're learning PHP, functions are one of the first concepts that can make your code dramatically easier to write and maintain. Instead of repeating the same instructions throughout a program, you can place them inside a function and reuse that logic whenever you need it.

A PHP function can be as simple as displaying a message or as useful as validating form data, calculating a price, processing an array, or handling part of a larger application. PHP also provides thousands of built-in functions, while developers can create their own user-defined functions.

This guide explains how to create and call functions in PHP, pass arguments, return values, use default parameters, work with references, and build recursive functions. The examples are designed to help beginners understand not just the syntax, but when each approach is useful.

What Is a Function in PHP?

A function is a reusable block of PHP code designed to perform a particular task. Once defined, it can be called whenever that task needs to be performed.

A basic user-defined function follows this structure:

function functionName() {
    // Code to execute
}

The function keyword tells PHP that you are defining a function. The function name identifies it, parentheses contain its parameters if it has any, and curly braces contain the code that runs when the function is called.

For example:

function sayHello() {
    echo "Hello, World!";
}

sayHello();

The function is defined first and then executed with sayHello().

Why Use Functions?

Functions make PHP programs easier to organize because the same logic does not need to be written repeatedly.

Some major benefits include:

• Code reuse: Write logic once and use it multiple times.
• Better readability: A descriptive function name explains what the code does.
• Easier maintenance: Changes can usually be made in one place.
• Less repetition: Reusable operations do not have to be copied throughout a project.
• Simpler debugging: Smaller pieces of functionality are easier to test.

A good function should generally have one clear responsibility. For example, calculateTotal() is easier to understand than a large function that calculates a total, sends an email, updates a database, and generates HTML.

How to Create a Function in PHP

Creating a PHP function is straightforward.

function greetUser() {
    echo "Welcome to my website!";
}

To execute it, call the function by its name followed by parentheses:

greetUser();

Output:

Welcome to my website!

A valid PHP function name starts with a letter or underscore and can then contain letters, numbers, and underscores. Function names are case-insensitive for ASCII letters, although consistent naming is strongly recommended.

For example, these are reasonable names:

calculateTotal();
getUserName();
send_email();

Names such as 123function() are invalid because a function name cannot begin with a number.

Function Naming Best Practices

Choose names that describe the function's purpose.

Instead of:

function abc() {
    // ...
}

prefer:

function calculateDiscount() {
    // ...
}

When another developer reads calculateDiscount(), they immediately have an idea of what the function is supposed to do.

How to Pass Parameters to a PHP Function

Functions become much more useful when they can accept data.

Parameters are variables declared in the function definition. Arguments are the actual values supplied when the function is called. PHP supports value passing, reference passing, default arguments, variable-length arguments, and named arguments.

Consider this example:

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

$result = addNumbers(10, 20);

echo $result;

Output:

30

Here, $a and $b are parameters, while 10 and 20 are arguments.

Using Multiple Parameters

You can pass several values to a function:

function introduce($name, $age) {
    echo "My name is $name and I am $age years old.";
}

introduce("Rahul", 25);

Output:

My name is Rahul and I am 25 years old.

The order matters when using normal positional arguments. The first argument is assigned to the first parameter, the second to the second parameter, and so on.

Returning Values From a PHP Function

A function does not always need to print something. Often, it should calculate or process a value and return the result.

Use the return statement for this:

function square($number) {
    return $number * $number;
}

$result = square(5);

echo $result;

Output:

25

The important difference is that echo displays a value immediately, while return sends a value back to the code that called the function. PHP functions can return values of different types, including arrays and objects. If a function reaches its end without returning a value, the return value is null.

For reusable application logic, returning a result is often more flexible than printing directly.

For example:

function calculatePrice($price, $tax) {
    return $price + ($price * $tax / 100);
}

$total = calculatePrice(100, 18);

echo $total;

The returned value can then be displayed, stored, compared, or passed to another function.

PHP Functions With Default Parameters

Sometimes a function should use a standard value when the caller does not provide one.

PHP supports default parameter values:

function greet($name = "Guest") {
    echo "Hello, $name!";
}

greet();
greet("Amit");

The first call uses the default value:

Hello, Guest!

The second uses the supplied argument:

Hello, Amit!

Default parameters are useful when a function has an optional setting or value. PHP supports default values for scalar values, arrays, null, and certain object defaults.

When designing a function, required parameters should generally come before optional parameters.

Passing Arguments by Reference in PHP

By default, function arguments are passed by value. If you want a function to modify the variable supplied by the caller, you can pass the parameter by reference using & in the function definition.

Example:

function addText(&$text) {
    $text .= " - Updated";
}

$message = "Hello";

addText($message);

echo $message;

Output:

Hello - Updated

The function changed the original $message variable.

Notice where the ampersand appears:

function addText(&$text)

You do not need to write an ampersand when calling the function:

addText($message);

This is an important difference for beginners.

When Should You Use References?

References should be used deliberately because they allow a function to change data outside its own local scope.

For many situations, returning a new value is clearer:

function addText($text) {
    return $text . " - Updated";
}

$message = addText($message);

This makes the data flow easier to understand and avoids unexpected modifications.

Recursive Functions in PHP

A recursive function is a function that calls itself.

Recursion can be useful when solving problems that naturally break down into smaller versions of the same problem, such as processing hierarchical data or calculating factorials.

Here is a simple factorial example:

function factorial($number) {
    if ($number <= 1) {
        return 1;
    }

    return $number * factorial($number - 1);
}

echo factorial(5);

Output:

120

The calculation works conceptually like this:

5 × 4 × 3 × 2 × 1 = 120

The most important part of recursion is the termination condition. Without a condition that eventually stops the function from calling itself, the function can continue indefinitely and cause problems.

PHP supports recursive user-defined functions.

When Is Recursion Useful?

Recursion can be appropriate for:

• Tree structures
• Nested categories
• Directory structures
• Hierarchical menus
• Certain mathematical calculations
• Divide-and-conquer algorithms

However, recursion is not automatically better than a loop. For straightforward repetitive tasks, a loop is often easier to read and maintain.

Anonymous Functions in PHP

PHP also supports anonymous functions, sometimes called closures. Unlike a traditional named function, an anonymous function does not need a function name.

Example:

$greet = function($name) {
    return "Hello, $name!";
};

echo $greet("Neha");

Anonymous functions are useful when you need a function temporarily, particularly when working with callbacks and other functions that accept callable behavior. PHP's function system also includes arrow functions and first-class callable syntax.

For example, an anonymous function can be passed directly to another operation rather than creating a separate named function that will never be reused.

Variable-Length Function Arguments

Sometimes you do not know in advance how many values a function will receive.

PHP supports variable-length arguments using the ... syntax:

function sum(...$numbers) {
    $total = 0;

    foreach ($numbers as $number) {
        $total += $number;
    }

    return $total;
}

echo sum(10, 20, 30, 40);

Output:

100

The ...$numbers parameter collects the additional arguments into an array. PHP also supports using ... when calling functions to unpack an array into individual arguments.

This technique is useful when a function needs to accept a flexible number of inputs. Check how to secure input in php - with complete example.

Named Arguments in PHP

Modern PHP also supports named arguments. Instead of relying entirely on parameter position, you can specify the parameter name:

function createUser($name, $age, $country = "India") {
    return "$name, $age, $country";
}

echo createUser(
    name: "Ravi",
    age: 28
);

Named arguments were introduced in PHP 8.0. They can make calls easier to understand, especially when a function has several optional parameters.

They can also allow optional arguments to be supplied without specifying every preceding optional parameter.

Use them carefully when working with public APIs, because changing parameter names can affect callers that rely on those names.

Built-In vs User-Defined PHP Functions

PHP provides a large collection of built-in functions for common programming tasks. These include functions for working with strings, arrays, dates, files, JSON, and many other operations.

For example:

$name = "Legend Blogs";

echo strlen($name);

strlen() is a built-in PHP function.

A user-defined function, on the other hand, is created by the developer:

function getSiteName() {
    return "Legend Blogs";
}

You should generally check whether PHP already provides a suitable built-in function before writing your own version. This can reduce unnecessary code and make applications easier to maintain.

Common Mistakes When Using PHP Functions

Forgetting to Call the Function

Defining a function does not necessarily execute its body.

function hello() {
    echo "Hello";
}

You need:

hello();

to execute it.

Forgetting Required Arguments

If a function requires parameters, make sure the necessary arguments are supplied.

function multiply($a, $b) {
    return $a * $b;
}

multiply(5, 10);

Passing too few required arguments can result in an ArgumentCountError in modern PHP versions.

Using echo When You Need return

This can make a function harder to reuse.

Less flexible:

function total($a, $b) {
    echo $a + $b;
}

More reusable:

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

You can then decide what to do with the result.

Modifying Variables by Reference Without a Good Reason

Passing by reference can be useful, but it also means the function can change the caller's variable. If that behavior is unexpected, debugging becomes harder.

Prefer returning values unless modifying the original variable is genuinely part of the function's purpose.

Best Practices for Writing PHP Functions

Good functions are not simply functions that work. They should also make the codebase easier to understand.

Give Functions Clear Names

Use descriptive names such as:

calculateTax()
validateEmail()
getUserById()
sendConfirmationEmail()

Avoid vague names that hide the function's purpose.

Keep Functions Focused

A function should ideally perform one logical task.

For example, a calculateTotal() function should calculate a total rather than also sending an email and updating a database.

Return Useful Data

When practical, return results rather than printing them directly. This allows the calling code to decide whether to display, store, compare, or transform the result.

Avoid Excessively Large Functions

If one function contains dozens or hundreds of lines and handles unrelated responsibilities, it may be a sign that the logic should be divided into smaller functions.

Use Type Declarations When Appropriate

Modern PHP supports parameter and return type declarations, which can make function contracts clearer and help catch incorrect values.

For example:

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

The declaration tells readers and PHP what kinds of values the function expects and returns.

FAQ

What is a function in PHP?

A PHP function is a reusable block of code that performs a specific task. You define it with the function keyword and call it by its name.

How do I call a function in PHP?

Write the function name followed by parentheses. For example:

sayHello();

If the function requires arguments, place them inside the parentheses.

What is the difference between a parameter and an argument in PHP?

A parameter is the variable defined in a function declaration, while an argument is the actual value supplied when the function is called.

How do I return a value from a PHP function?

Use the return statement:

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

The returned result can then be assigned to a variable or used in another expression.

Can a PHP function accept multiple parameters?

Yes. A function can accept multiple parameters separated by commas:

function calculate($price, $tax, $discount) {
    // ...
}

PHP also supports variable-length argument lists with ....

What does & mean in a PHP function?

When placed before a parameter in a function definition, & means the argument is passed by reference. This allows the function to modify the original variable supplied by the caller.

Can a PHP function call itself?

Yes. A function can call itself, which is known as recursion. Recursive functions need a condition that eventually stops the recursive calls.

Should I use return or echo inside a PHP function?

Use return when the function should provide a result to the calling code. Use echo when the function's specific purpose is to produce output directly. For reusable business logic, return is often the more flexible choice.

Conclusion

Learning how to use functions in PHP is a major step toward writing cleaner and more maintainable applications. A function lets you package a specific task into reusable code instead of repeating the same logic throughout a project.

Start with simple functions, then practice passing parameters and returning values. Once those fundamentals are comfortable, explore default parameters, references, recursion, anonymous functions, variable-length arguments, and named arguments.

The most important habit is to design functions around clear responsibilities. A well-named, focused function makes PHP code easier to read, test, debug, and extend as an application grows.

For current PHP syntax and behavior, the official PHP documentation is the best reference, particularly when working with newer features such as named arguments and variable-length parameters.