PHP Fundamentals

Functions in PHP

13 min Lesson 9 of 45

Functions in PHP

Functions are reusable blocks of code that perform specific tasks. They help organize code, improve readability, and prevent repetition. Functions are fundamental to writing maintainable and efficient PHP applications.

Defining Functions

Use the function keyword to define a function:

<?php
// Basic function definition:
function greet() {
    echo "Hello, World!";
}

// Calling the function:
greet(); // Output: Hello, World!

// Function with multiple statements:
function displayInfo() {
    echo "This is line 1<br>";
    echo "This is line 2<br>";
    echo "This is line 3<br>";
}

displayInfo();
?>

Note: Function names are case-insensitive in PHP. greet(), Greet(), and GREET() all refer to the same function. However, it's best practice to use consistent naming conventions.

Function Parameters

Parameters allow you to pass data into functions:

<?php
// Function with single parameter:
function greet($name) {
    echo "Hello, $name!";
}

greet("John"); // Output: Hello, John!
greet("Sarah"); // Output: Hello, Sarah!

// Function with multiple parameters:
function add($a, $b) {
    echo $a + $b;
}

add(5, 3); // Output: 8

// Function with many parameters:
function createUser($name, $email, $age, $city) {
    echo "User: $name, Email: $email, Age: $age, City: $city";
}

createUser("John", "john@example.com", 30, "New York");
?>

Default Parameter Values

You can specify default values for parameters:

<?php
// Default parameter values:
function greet($name = "Guest") {
    echo "Hello, $name!";
}

greet(); // Output: Hello, Guest!
greet("John"); // Output: Hello, John!

// Multiple defaults:
function createPost($title, $status = "draft", $featured = false) {
    echo "Title: $title, Status: $status, Featured: " .
         ($featured ? "Yes" : "No");
}

createPost("My Post"); // Uses defaults for status and featured
createPost("My Post", "published"); // Uses default for featured
createPost("My Post", "published", true); // No defaults used
?>

Tip: Parameters with default values should be placed after parameters without defaults. This prevents errors and makes your function calls more intuitive.

Return Values

Functions can return values using the return statement:

<?php
// Function that returns a value:
function add($a, $b) {
    return $a + $b;
}

$result = add(5, 3);
echo $result; // Output: 8

// Using return value directly:
echo add(10, 20); // Output: 30

// Function with multiple return points:
function getGrade($score) {
    if ($score >= 90) return "A";
    if ($score >= 80) return "B";
    if ($score >= 70) return "C";
    if ($score >= 60) return "D";
    return "F";
}

echo getGrade(85); // Output: B

// Returning arrays:
function getUser() {
    return [
        'name' => 'John',
        'email' => 'john@example.com',
        'age' => 30
    ];
}

$user = getUser();
echo $user['name']; // Output: John
?>

Note: When a return statement is executed, the function immediately exits. Any code after the return statement will not be executed.

Type Declarations

PHP allows you to specify parameter types and return types (PHP 7.0+):

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

echo add(5, 3); // Output: 8
// add("5", "3"); // Works: strings are converted to integers

// Return type declaration:
function multiply(int $a, int $b): int {
    return $a * $b;
}

// Multiple types with union types (PHP 8.0+):
function display(string|int $value): void {
    echo $value;
}

// Nullable types:
function findUser(int $id): ?array {
    // Returns array or null
    return null; // No user found
}
?>

Passing by Reference

By default, arguments are passed by value. Use & to pass by reference:

<?php
// Pass by value (default):
function incrementValue($num) {
    $num++;
    echo "Inside: $num<br>";
}

$x = 5;
incrementValue($x);
echo "Outside: $x"; // Output: 5 (unchanged)

// Pass by reference:
function incrementReference(&$num) {
    $num++;
    echo "Inside: $num<br>";
}

$y = 5;
incrementReference($y);
echo "Outside: $y"; // Output: 6 (changed)
?>

Warning: Use pass-by-reference sparingly. It makes code harder to understand and debug. Prefer returning values instead.

Variable Functions

PHP allows you to call functions dynamically using variables:

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

function sayGoodbye() {
    echo "Goodbye!";
}

// Call function using variable:
$functionName = "sayHello";
$functionName(); // Output: Hello!

$functionName = "sayGoodbye";
$functionName(); // Output: Goodbye!

// Practical example:
$action = $_GET['action'] ?? 'default';

$allowedActions = ['create', 'update', 'delete'];

if (in_array($action, $allowedActions)) {
    $functionName = $action . 'Post';
    if (function_exists($functionName)) {
        $functionName();
    }
}
?>

Anonymous Functions (Closures)

Anonymous functions don't have a name and can be stored in variables:

<?php
// Anonymous function assigned to variable:
$greet = function($name) {
    echo "Hello, $name!";
};

$greet("John"); // Output: Hello, John!

// Anonymous function as callback:
$numbers = [1, 2, 3, 4, 5];

$squared = array_map(function($n) {
    return $n * $n;
}, $numbers);

print_r($squared); // [1, 4, 9, 16, 25]

// Anonymous function with use():
$multiplier = 10;

$multiply = function($n) use ($multiplier) {
    return $n * $multiplier;
};

echo $multiply(5); // Output: 50
?>

Arrow Functions (PHP 7.4+)

Arrow functions provide shorter syntax for simple anonymous functions:

<?php
// Traditional anonymous function:
$numbers = [1, 2, 3, 4, 5];

$squared = array_map(function($n) {
    return $n * $n;
}, $numbers);

// Arrow function (shorter):
$squared = array_map(fn($n) => $n * $n, $numbers);

// Arrow functions automatically capture variables:
$multiplier = 10;
$multiply = fn($n) => $n * $multiplier;

echo $multiply(5); // Output: 50
?>

Tip: Arrow functions are great for simple, one-line operations. For complex logic, use traditional anonymous functions or named functions.

Practical Examples

Example 1: Input Validation

<?php
function validateEmail($email) {
    return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
}

function validateAge($age) {
    return is_numeric($age) && $age >= 18 && $age <= 120;
}

function validateUsername($username) {
    return strlen($username) >= 3 && strlen($username) <= 20;
}

// Usage:
$email = "user@example.com";
if (validateEmail($email)) {
    echo "Valid email";
} else {
    echo "Invalid email";
}
?>

Example 2: Data Formatting

<?php
function formatCurrency($amount, $currency = "USD") {
    return $currency . " " . number_format($amount, 2);
}

function formatDate($date, $format = "Y-m-d") {
    return date($format, strtotime($date));
}

function slugify($text) {
    $text = strtolower($text);
    $text = preg_replace('/[^a-z0-9]+/', '-', $text);
    return trim($text, '-');
}

// Usage:
echo formatCurrency(1234.567); // USD 1,234.57
echo formatDate("2024-12-25", "F j, Y"); // December 25, 2024
echo slugify("Hello World!"); // hello-world
?>

Example 3: Array Helpers

<?php
function arrayFirst($array) {
    return count($array) > 0 ? $array[0] : null;
}

function arrayLast($array) {
    return count($array) > 0 ? $array[count($array) - 1] : null;
}

function arrayPluck($array, $key) {
    return array_map(fn($item) => $item[$key] ?? null, $array);
}

// Usage:
$users = [
    ['name' => 'John', 'age' => 30],
    ['name' => 'Jane', 'age' => 25],
    ['name' => 'Bob', 'age' => 35]
];

$names = arrayPluck($users, 'name');
print_r($names); // ['John', 'Jane', 'Bob']
?>

Function Best Practices

1. Single Responsibility Principle

<?php
// BAD: Function does too many things
function processUser($data) {
    // Validate
    // Save to database
    // Send email
    // Log activity
    // Update cache
}

// GOOD: Split into focused functions
function validateUser($data) { }
function saveUser($data) { }
function sendWelcomeEmail($user) { }
function logUserActivity($user) { }
?>

2. Descriptive Naming

<?php
// BAD: Unclear names
function calc($a, $b) { }
function process($d) { }

// GOOD: Clear, descriptive names
function calculateTotalPrice($quantity, $unitPrice) { }
function processPayment($paymentData) { }
function getUserByEmail($email) { }
function isValidPassword($password) { }
?>

3. Keep Functions Short

Note: Aim for functions that do one thing well. If a function exceeds 20-30 lines, consider breaking it into smaller functions.

Built-in Function Examples

<?php
// Check if function exists:
if (function_exists('myFunction')) {
    myFunction();
}

// Get list of defined functions:
$functions = get_defined_functions();

// Get function arguments:
function example($a, $b, $c = 10) {
    $args = func_get_args();
    print_r($args);
}

example(1, 2, 3); // [1, 2, 3]

// Number of arguments:
function example2() {
    echo func_num_args();
}

example2(1, 2, 3, 4); // Output: 4
?>

Practice Exercise

Task: Create a simple calculator with functions:

Create functions for add, subtract, multiply, and divide operations
Each function should take two numbers as parameters
Division function should check for division by zero
Create a calculate($operation, $a, $b) function that calls the appropriate operation
Bonus: Add functions for percentage, power, and square root
Extra: Create a formatResult($result, $decimals = 2) function to format the output
Challenge: Add parameter type declarations and return types to all functions

Common Pitfalls to Avoid

Don't use too many parameters (more than 4-5 suggests refactoring needed)
Avoid global variables inside functions - pass data as parameters
Don't modify parameters passed by value expecting changes outside
Avoid functions with side effects that aren't obvious from the name
Don't create functions that return different types based on conditions
Avoid deeply nested logic - extract into helper functions

Summary

Functions are essential building blocks in PHP programming:

Use function keyword to define reusable code blocks
Parameters allow passing data into functions
Use return to send values back to the caller
Default parameters provide flexibility
Type declarations improve code reliability
Anonymous functions and arrow functions enable functional programming
Keep functions focused, short, and well-named
Follow best practices for maintainable code