Defining and Calling Functions

In PHP, functions are defined using the function keyword, followed by the function name, a list of parameters in parentheses, and a block of code. The function can optionally return a value using the return statement.

<?php
function greet($name) {
    return "Hello, " . $name . "!";
}

echo greet("Alice"); // Outputs: Hello, Alice!
?>

Function names follow the same rules as other PHP identifiers: they must start with a letter or underscore and can include letters, numbers, and underscores. It is a common best practice to use camelCase or snake_case for function names to improve readability.

Function Parameters and Default Values

PHP functions can accept zero or more parameters. Parameters can also be assigned default values, allowing the function to be called with fewer arguments.

<?php
function greet($name = "Guest") {
    return "Hello, " . $name . "!";
}

echo greet(); // Outputs: Hello, Guest!
echo greet("Bob"); // Outputs: Hello, Bob!
?>

Default values are evaluated at the time the function is defined, not when it is called, so care must be taken when using expressions as defaults.

Variable-Length Argument Lists

PHP supports variable-length argument lists using the ... operator (introduced in PHP 5.6), allowing a function to accept an arbitrary number of arguments.

<?php
function sum(...$numbers) {
    return array_sum($numbers);
}

echo sum(1, 2, 3); // Outputs: 6
echo sum(4, 5, 6, 7); // Outputs: 22
?>

This feature is useful for writing flexible functions, especially for utility or helper functions.

Return Types and Type Declarations

Starting with PHP 7, functions can declare return types and parameter types. This helps catch errors early and improves code clarity.

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

echo add(3, 5); // Outputs: 8
// echo add("3", "5"); // Throws a TypeError
?>

Use of strict typing is recommended in modern PHP development to ensure type safety and improve performance.

Anonymous Functions and Closures

PHP allows the definition of anonymous functions, also known as closures. These are often used in callbacks and functional programming patterns.

<?php
$greet = function($name) {
    return "Hello, " . $name . "!";
};

echo $greet("Charlie"); // Outputs: Hello, Charlie!
?>

Closures can also access variables from the parent scope using the use keyword.

<?php
$greeting = "Hi";
$greet = function($name) use ($greeting) {
    return $greeting . ", " . $name . "!";
};

echo $greet("Dave"); // Outputs: Hi, Dave!
?>

Function Best Practices

PracticeDescriptionExample
Use descriptive namesFunction names should clearly indicate their purpose.calculateTotalPrice() vs calc()
Keep functions small and focusedA function should perform a single task.Avoid writing a function that both calculates and formats output.
Avoid side effectsFunctions should not modify global state or external resources unless necessary.Prefer pure functions that return values based on input.
Use type declarationsImprove code reliability and performance by specifying types.function findUser(int $id): ?User { ... }
Return null for missing resultsUse null to indicate absence of a result, not false.function getUser(int $id): ?User { ... }

Function Scope and Namespaces

In PHP, functions defined in the global scope are accessible throughout the script, unless overridden. To avoid naming conflicts and organize code, use namespaces.

<?php
namespace App\Helpers;

function logMessage(string $message) {
    file_put_contents("log.txt", $message . PHP_EOL, FILE_APPEND);
}

To call a namespaced function, use the fully qualified name or import the namespace.

<?php
use App\Helpers\logMessage;

logMessage("User logged in.");

Learn more with useful resources