PHP Anonymous Functions : A Tutorial with Examples

In PHP, anonymous functions (also known as closures) are functions that do not have a specified name. They are often used as callbacks or passed as arguments to other functions, allowing for more flexible and dynamic code.

Anonymous functions can be created on the fly and are particularly useful when you need to define simple or one-off functions.

In this tutorial, we will cover:

Let’s dive into each of these topics with examples and explanations.

1. What is an Anonymous Function?

An anonymous function is a function that has no name and is often used when a function is required but does not need to be reused. Anonymous functions can be assigned to variables or passed as arguments to other functions. They are defined using the function keyword.

Syntax:

function (parameters) {
    // function body
};

2. Creating and Calling Anonymous Functions

You can define an anonymous function and immediately call it by assigning it to a variable or executing it directly.

Example (Anonymous Function):

<?php
// Define an anonymous function and assign it to a variable
$greet = function () {
    echo "Hello, World!\n";
};

// Call the anonymous function
$greet();
?>

Output:

Hello, World!

• In this example, we define an anonymous function that prints “Hello, World!” and assign it to the variable $greet. The function is then called using $greet().

3. Anonymous Functions as Function Arguments

Anonymous functions are often passed as callback arguments to other functions. PHP functions such as array_map(), array_filter(), and usort() frequently use anonymous functions as parameters.

Example (Using Anonymous Functions as Function Arguments):

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

// Use an anonymous function to multiply each number by 2
$doubled = array_map(function ($n) {
    return $n * 2;
}, $numbers);

// Print the result
print_r($doubled);
?>

Output:

Array
(
    [0] => 2
    [1] => 4
    [2] => 6
    [3] => 8
    [4] => 10
)

• In this example, an anonymous function is passed as a callback to array_map(). The function takes each number in the array and multiplies it by 2.

4. Storing Anonymous Functions in Variables

In PHP, anonymous functions can be stored in variables, allowing you to pass them around and call them later. This makes them highly flexible and reusable within specific contexts.

Example (Storing Anonymous Functions in Variables):

<?php
// Store an anonymous function in a variable
$square = function ($n) {
    return $n * $n;
};

// Call the anonymous function
echo $square(4);  // Outputs: 16
?>

• In this example, an anonymous function that calculates the square of a number is stored in the variable $square. The function is then called using $square(4).

5. Anonymous Functions with Parameters

Anonymous functions can take parameters just like regular functions. You can pass arguments to anonymous functions and return values from them.

Example (Anonymous Function with Parameters):

<?php
// Define an anonymous function with two parameters
$add = function ($a, $b) {
    return $a + $b;
};

// Call the function with arguments
echo $add(5, 3);  // Outputs: 8
?>

• In this example, the anonymous function takes two parameters ($a and $b) and returns their sum. The function is called with the arguments 5 and 3.

6. Capturing Variables from the Parent Scope (use Keyword)

Anonymous functions in PHP can capture variables from their surrounding scope using the use keyword. This is useful when you want the function to have access to variables that are not passed as parameters.

Example (Capturing Variables from Parent Scope):

<?php
$factor = 3;

// Anonymous function capturing $factor from the parent scope
$multiply = function ($n) use ($factor) {
    return $n * $factor;
};

// Call the function
echo $multiply(5);  // Outputs: 15
?>

• In this example, the anonymous function captures the variable $factor from the parent scope using the use keyword. It multiplies the passed argument (5) by $factor.

Important Note:

• The use keyword captures by value, meaning the captured variable’s value is fixed at the time the function is defined. To capture by reference, use & before the variable name in the use statement.

Example (Capturing by Reference):

<?php
$counter = 0;

// Anonymous function capturing $counter by reference
$increment = function () use (&$counter) {
    $counter++;
};

$increment();
$increment();
echo $counter;  // Outputs: 2
?>

• In this example, $counter is captured by reference, so its value is updated each time the anonymous function is called.

7. Returning Anonymous Functions

Anonymous functions can also return other anonymous functions, allowing you to build dynamic functions or closures.

Example (Returning Anonymous Functions):

<?php
// Function that returns an anonymous function
function createMultiplier($factor) {
    return function ($n) use ($factor) {
        return $n * $factor;
    };
}

// Create a multiplier function for 3
$triple = createMultiplier(3);

// Call the returned function
echo $triple(5);  // Outputs: 15
?>

• In this example, the function createMultiplier() returns an anonymous function that multiplies a number by the given $factor. The returned function is then used to multiply 5 by 3.

8. Example Use Case: Array Operations with Anonymous Functions

Let’s combine the concepts we’ve learned into a more practical example where anonymous functions are used to filter and transform an array.

Example (Using Anonymous Functions for Array Operations):

<?php
$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Step 1: Filter even numbers
$evens = array_filter($numbers, function ($n) {
    return $n % 2 === 0;
});

// Step 2: Multiply each even number by 3
$multiplied = array_map(function ($n) {
    return $n * 3;
}, $evens);

// Step 3: Calculate the sum of the multiplied numbers
$sum = array_reduce($multiplied, function ($carry, $n) {
    return $carry + $n;
}, 0);

// Print results
echo "Even numbers: " . implode(", ", $evens) . "\n";
echo "Multiplied by 3: " . implode(", ", $multiplied) . "\n";
echo "Sum of multiplied numbers: $sum\n";
?>

Output:

Even numbers: 2, 4, 6, 8, 10
Multiplied by 3: 6, 12, 18, 24, 30
Sum of multiplied numbers: 90

• In this example, we use anonymous functions to:
  • Filter the even numbers from the $numbers array.
  • Multiply the filtered numbers by 3.
  • Sum the results of the multiplication.

This demonstrates how anonymous functions can simplify array operations and processing.

Summary of PHP Anonymous Functions:

Conclusion

Anonymous functions (closures) in PHP are a powerful tool for writing more flexible and concise code, especially when you need a quick function for one-off operations or callbacks.

In this tutorial, we covered:

• Creating and calling anonymous functions.
• Using anonymous functions as function arguments, particularly in array operations.
• Capturing variables from the parent scope using the use keyword.
• Returning anonymous functions for more dynamic and flexible code.
• A practical example of array operations using anonymous functions.