Functions

Introduction

As programs grow, repeating the same block of code over and over becomes messy and error-prone. Functions let you package a piece of logic under a name, so you can reuse it, test it in isolation, and change it in one place instead of everywhere it is used.

In this lesson you will learn how to define and call functions, use parameters with default values, declare return types, accept a variable number of arguments with variadic parameters, and write short arrow functions introduced in PHP 7.4.

Defining and Calling a Function

A function is defined with the function keyword, a name, a parameter list in parentheses, and a body in braces. Once defined, you call it by writing its name followed by parentheses.

<?php
function greet() {
    echo "Hello there!";
}

greet();

Hello there!

Function names are case-insensitive in PHP (though matching the defined case is good practice), and a function must be defined before it is called, unless it is defined at the top level of a file, in which case PHP makes it available throughout that file.

Parameters and Default Values

Parameters let a function accept input. You can give any parameter a default value, which is used automatically when the caller does not supply that argument.

<?php
function greet($name) {
    echo "Hello, $name!\n";
}

greet("Maria");
greet("Sam");

Hello, Maria!
Hello, Sam!

<?php
function greet($name = "Guest") {
    echo "Hello, $name!\n";
}

greet("Maria");
greet();

Hello, Maria!
Hello, Guest!

Return Values and Type Declarations

A function sends a result back to the caller using return, which also immediately ends the function's execution. You can optionally declare the type of each parameter and the return type, which helps PHP catch mistakes and makes the function's contract clear to anyone reading it.

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

$sum = add(4, 7);
echo "Sum: $sum";

Sum: 11

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

echo add(4, 7);
echo "\n";
echo add(2.5, 1);

11
3

In the second call, add(2.5, 1), PHP coerces the float 2.5 down to the int type declared for the parameter (becoming 2) unless strict_types is enabled, in which case a type mismatch like this would throw a TypeError instead.

Variadic Functions

Sometimes you do not know in advance how many arguments will be passed. A variadic parameter, written with three dots before the variable name (...$args), collects any number of trailing arguments into a single array inside the function.

<?php
function sumAll(...$numbers) {
    $total = 0;
    foreach ($numbers as $number) {
        $total += $number;
    }
    return $total;
}

echo sumAll(1, 2, 3);
echo "\n";
echo sumAll(10, 20, 30, 40, 50);

6
150

You can also combine regular parameters with a variadic one, as long as the variadic parameter comes last.

<?php
function describe($label, ...$items) {
    echo "$label: " . implode(", ", $items);
}

describe("Fruits", "Apple", "Banana", "Cherry");

Fruits: Apple, Banana, Cherry

Arrow Functions

PHP 7.4 introduced arrow functions as a compact shorthand for simple, single-expression functions, using the fn keyword. The result of the expression is returned automatically — there is no need to write return explicitly.

<?php
$double = fn($x) => $x * 2;

echo $double(5);

10

Arrow functions also automatically capture variables from the surrounding scope by value, without needing an explicit use clause like regular anonymous functions require. They are especially handy for short callbacks passed to array functions.

<?php
$numbers = [1, 2, 3, 4, 5];

$squared = array_map(fn($n) => $n * $n, $numbers);

echo implode(", ", $squared);

1, 4, 9, 16, 25

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Functions are the primary way to organize and reuse logic in PHP. You now know how to define and call them, work with parameters and default values, declare types, accept a flexible number of arguments with variadic parameters, and write concise arrow functions for simple cases.