← Back to Curriculum

Functions

📚 Lesson 4 of 12 ⏱️ 35 min

Functions

35 min

Functions are fundamental building blocks in PHP that allow you to group code into reusable, named blocks. Functions help you avoid code duplication, improve organization, and make code more maintainable. PHP functions can accept parameters, return values, and have default parameter values. Understanding functions is essential for writing organized, reusable PHP code. Functions enable you to break complex problems into smaller, manageable pieces.

Function syntax includes the `function` keyword, function name, parameters in parentheses, and a body in curly braces. Function names are case-insensitive but should be used consistently. PHP supports default parameter values, allowing you to call functions with fewer arguments. Parameters can have type hints (PHP 7.0+) specifying expected types, and functions can declare return types (PHP 7.0+). Understanding function syntax and features helps you write clear, type-safe functions.

PHP 7.0+ introduced scalar type hints (int, float, string, bool) and return type declarations. Type hints help catch errors early and make function contracts clear. Return type declarations specify what a function returns, improving code clarity and enabling better IDE support. PHP 7.1+ added nullable types (using `?`), and PHP 8.0+ added union types. Understanding type hints and return types helps you write more robust, self-documenting code.

Variable-length argument lists enable functions to accept any number of arguments. The `...` operator (variadic functions) collects arguments into an array. This is useful for functions like `max()`, `min()`, or custom functions that need flexibility. PHP also provides `func_get_args()`, `func_num_args()`, and `func_get_arg()` for accessing arguments, though variadic functions are preferred. Understanding variadic functions helps you write flexible, reusable code.

Anonymous functions (closures) and arrow functions (PHP 7.4+) enable you to create functions without names. Closures can capture variables from their surrounding scope using the `use` keyword. Arrow functions are more concise closures that automatically capture variables from the enclosing scope. These are useful for callbacks, array functions like `array_map()` and `array_filter()`, and event handlers. Understanding closures and arrow functions helps you write more expressive, functional-style PHP code.

Best practices include using descriptive function names, keeping functions focused on a single responsibility, using type hints and return types, documenting functions with docblocks, and avoiding functions that are too long or complex. Functions should be testable, reusable, and well-documented. Understanding functions enables you to write organized, maintainable PHP applications.

Key Concepts

  • Functions group code into reusable, named blocks.
  • PHP supports default parameter values and type hints.
  • Return type declarations specify what functions return.
  • Variadic functions accept variable numbers of arguments.
  • Closures and arrow functions enable anonymous functions.

Learning Objectives

Master

  • Creating and calling functions with parameters
  • Using default parameter values and type hints
  • Working with return types and nullable types
  • Creating closures and arrow functions for callbacks

Develop

  • Code organization and reusability thinking
  • Understanding function design and best practices
  • Writing type-safe, well-documented functions

Tips

  • Use descriptive function names that indicate what the function does.
  • Use type hints and return types for better code quality.
  • Keep functions focused on a single responsibility.
  • Use closures and arrow functions for callbacks and array operations.

Common Pitfalls

  • Creating functions that are too long or do too many things.
  • Not using type hints, missing opportunities for better code quality.
  • Forgetting return statements, causing functions to return null.
  • Not documenting functions, making code harder to understand.

Summary

  • Functions group code into reusable blocks.
  • Type hints and return types improve code quality.
  • Default parameters and variadic functions provide flexibility.
  • Closures and arrow functions enable functional programming patterns.
  • Understanding functions is essential for organized PHP code.

Exercise

Create various types of functions including regular functions, functions with default parameters, and anonymous functions.

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

// Function with default parameter
function createUser($name, $email, $age = 18) {
    return [
        "name" => $name,
        "email" => $email,
        "age" => $age
    ];
}

// Function with type hints and return type
function calculateArea(float $width, float $height): float {
    return $width * $height;
}

// Variable-length argument list
function sum(...$numbers) {
    return array_sum($numbers);
}

// Anonymous function (closure)
$multiply = function($a, $b) {
    return $a * $b;
};

// Arrow function (PHP 7.4+)
$divide = fn($a, $b) => $a / $b;

// Test the functions
echo greet("Alice") . "<br>";

$user = createUser("Bob", "bob@example.com", 25);
echo "User: " . $user["name"] . " (" . $user["email"] . ")<br>";

echo "Area: " . calculateArea(5.5, 3.2) . "<br>";
echo "Sum: " . sum(1, 2, 3, 4, 5) . "<br>";
echo "Multiply: " . $multiply(4, 5) . "<br>";
echo "Divide: " . $divide(10, 2) . "<br>";
?>

Code Editor

Output