PHP Functions

PHP Functions

Functions are reusable blocks of code that perform a specific task. PHP has a vast library of over 1000 built-in functions, and you can also define your own custom functions.

Using functions helps organize your code, makes it more readable, reduces repetition (following the DRY - Don’t Repeat Yourself - principle), and improves maintainability.

Defining Custom Functions

You define a function using the function keyword, followed by the function name, parentheses (), and a code block {}.

Syntax:

<?php
declare(strict_types=1); // Optional: Enforce strict type checking

function functionName(parameters) {
    // Code to be executed
    // Optional: return value;
}
?>

Naming Conventions:

• Function names must start with a letter or underscore (_), followed by letters, numbers, or underscores.
• Function names are case-insensitive, but it’s good practice to call them consistently (e.g., as defined).
• Choose descriptive names that indicate the function’s purpose (e.g., calculateTotal, getUserById, formatDate). Common casing styles include camelCase (like calculateTotal) or snake_case (like get_user_by_id).

A function definition doesn’t execute the code inside it immediately. You need to call the function to run its code.

Example: Simple Function Definition and Call

<?php
// Define the function
function displayWelcomeMessage() {
    echo "Hello! Welcome to our website.<br>";
}

// Call the function
displayWelcomeMessage();
// Output: Hello! Welcome to our website.<br>
displayWelcomeMessage(); // Call it again
// Output: Hello! Welcome to our website.<br>
?>

Function Arguments (Parameters)

Functions can accept input values, called arguments (or parameters in the function definition). Arguments are listed inside the parentheses in the function definition and act like local variables within the function.

<?php
function greetUser(string $name) { // $name is a parameter with type hint
    echo "Hello, " . htmlspecialchars($name) . "!<br>";
}

greetUser("Alice"); // "Alice" is the argument passed to the function
// Output: Hello, Alice!<br>
greetUser("Bob");
// Output: Hello, Bob!<br>
?>

Multiple Arguments: Separate them with commas.

<?php
function printUserInfo(string $name, int $age) {
    echo htmlspecialchars($name) . " is " . $age . " years old.<br>";
}

printUserInfo("Charlie", 30);
// Output: Charlie is 30 years old.<br>
?>

Type Hinting (Recommended):

Modern PHP strongly encourages type hinting for function parameters (and return types). This improves code clarity, helps catch errors early, and enables better tooling.

<?php
declare(strict_types=1); // Enable strict type checks

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

addNumbers(5, 10); // Output: 15
// addNumbers("5", "10"); // This would cause a TypeError if strict_types=1
?>

Default Argument Values

You can provide default values for arguments. If the function is called without passing that specific argument, the default value is used.

<?php
function setPowerLevel(int $level = 9000) { // Default level is 9000
    echo "The power level is: $level<br>";
}

setPowerLevel(15000); // Output: The power level is: 15000<br>
setPowerLevel();      // Output: The power level is: 9000<br>
?>

Note: Parameters with default values should generally come after parameters without default values in the function definition.

Returning Values

Functions can send a value back to the code that called them using the return statement. When return is executed, the function stops running immediately and passes the specified value back.

Return Type Hinting: You can (and should) specify the expected type of the return value using : type after the parentheses.

<?php
declare(strict_types=1);

function sum(int $x, int $y): int { // Declares it returns an integer
    $result = $x + $y;
    return $result;
    // Code after return is not executed
}

$total = sum(5, 10);
echo "5 + 10 = " . $total . "<br>"; // Output: 5 + 10 = 15<br>

echo "7 + 13 = " . sum(7, 13) . "<br>"; // Output: 7 + 13 = 20<br>

function formatGreeting(string $name): string {
    if (empty($name)) {
        return "Hello there!"; // Can return early
    }
    return "Hello, " . htmlspecialchars($name) . "!";
}

echo formatGreeting("Dana") . "<br>"; // Output: Hello, Dana!<br>
echo formatGreeting("") . "<br>";    // Output: Hello there!<br>
?>

If a function doesn’t have a return statement, or uses return; without a value, it implicitly returns null.

Variable Scope

Variables defined inside a function are local to that function by default. They cannot be accessed from outside the function, and variables defined outside cannot be accessed directly inside unless explicitly passed as arguments or declared as global (using global is generally discouraged; prefer passing arguments).

Further Function Concepts (Briefly)

• Variable-length argument lists (...): Allow a function to accept any number of arguments (e.g., function sum(...$numbers): int).
• Anonymous Functions (Closures): Functions without a specified name, often used as callbacks or assigned to variables.
• Arrow Functions (fn() => ...): A concise syntax for simple anonymous functions (introduced in PHP 7.4).

These advanced concepts provide more flexibility for specific programming patterns.