Understanding PHP Callbacks and Callable Type Hint

PHP uses callbacks to pass executable code as arguments to functions, enabling highly dynamic and flexible programming patterns. This article explains how callbacks work in PHP, the various ways to define them—including anonymous functions, object methods, and arrow functions—and how to use the callable type hint to enforce that a parameter can be executed as a function.

What is a PHP Callback?

A callback is any PHP variable or expression that can be invoked as a function. PHP allows you to pass these callbacks into other functions, where they are executed dynamically. The most common use case is in built-in array functions like array_map(), array_filter(), and usort().

Ways to Define Callbacks in PHP

PHP supports several ways to represent a callback, depending on whether you are calling a global function, an object method, a static method, or an anonymous function.

1. Global Functions (Strings)

You can refer to a standard global function by passing its name as a plain string.

function sayHello($name) {
    return "Hello, " . $name;
}

// Passing the function name as a string
$callback = 'sayHello';
echo $callback('Alice'); // Outputs: Hello, Alice

2. Anonymous Functions (Closures)

An anonymous function is a function defined without a name. It is represented by the Closure class in PHP.

$double = function($number) {
    return $number * 2;
};

echo $double(5); // Outputs: 10

3. Arrow Functions (PHP 7.4+)

Arrow functions are a shorthand syntax for simple anonymous functions. They automatically capture variables from the parent scope.

$multiplier = 3;
$triple = fn($number) => $number * $multiplier;

echo $triple(4); // Outputs: 12

4. Object Methods

To call an instance method on a specific object, pass an array where index 0 is the object instance, and index 1 is the method name.

class Greeter {
    public function greet($name) {
        return "Welcome, " . $name;
    }
}

$greeterObj = new Greeter();
$callback = [$greeterObj, 'greet'];

echo call_user_func($callback, 'Bob'); // Outputs: Welcome, Bob

5. Static Methods

To call a static class method, pass an array where index 0 is the class name (as a string) and index 1 is the method name. Alternatively, you can use a single string in the format 'ClassName::methodName'.

class MathHelper {
    public static function square($n) {
        return $n * $n;
    }
}

// Array syntax
$callback1 = ['MathHelper', 'square'];
// String syntax
$callback2 = 'MathHelper::square';

echo $callback1(4); // Outputs: 16
echo $callback2(5); // Outputs: 25

6. Invokable Objects

If an object implements the magic method __invoke(), the object itself can be passed and used directly as a callback.

class Calculator {
    public function __invoke($a, $b) {
        return $a + $b;
    }
}

$add = new Calculator();
echo $add(10, 20); // Outputs: 30

The callable Type Hint

The callable type hint enforces that an argument passed to a function or method must be a valid callback. If a value that cannot be executed is passed, PHP throws a TypeError.

Here is how you use callable to accept and execute a callback:

function processNumbers(array $numbers, callable $callback) {
    $results = [];
    foreach ($numbers as $number) {
        // Execute the callback dynamically
        $results[] = $callback($number);
    }
    return $results;
}

$data = [1, 2, 3, 4];

// Using an anonymous function as the callable argument
$squared = processNumbers($data, function($n) {
    return $n * $n;
});

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

Verifying Callbacks with is_callable()

If you are not using strict type hinting, or if you need to manually check if a variable can be executed as a function before running it, you can use the is_callable() function.

$var = 'nonExistentFunction';

if (is_callable($var)) {
    $var();
} else {
    echo "This variable is not callable.";
}