A callback is a function or method supplied to another operation so that operation can call it. array_map() receives a callback describing how to transform each item. A sorting function receives a callback describing the order. The surrounding operation owns the iteration; the callback supplies one piece of behavior.
An anonymous function is a function without a declared global name. It produces a Closure object that can be stored, passed and called. This guide explains common callback forms, local variable capture and the differences between returning a result and mutating shared state. You will finish by writing a small operation that accepts a formatting callback.
Common callable forms
A callback can be the string name of a defined function, an array containing an object and method name, an array containing a class and static method name, a Closure, or an invokable object implementing __invoke(). Modern PHP also supports first-class callable syntax such as trim(...), introduced in PHP 8.1, to obtain a callable value from a known function or method.
The parameter type callable says that an argument must be callable. It does not describe the callback's exact parameter and return contract. Document those expectations in prose or a PHPDoc annotation, and keep calls consistent. A formatter expecting one string should not unexpectedly receive a record and three extra arguments.
Visibility and static rules still apply to method callbacks. A private method is not universally callable from unrelated code, and a nonstatic method requires an object context. Check the callable from the scope that will actually invoke it. A callback representation is not permission to bypass encapsulation.
Capture outside values with use
An ordinary anonymous function does not automatically receive surrounding local variables. Add use ($discount) to capture a selected value. By-value capture records the value when the closure is created. Later reassignment of the outer variable does not automatically update the captured scalar value.
use (&$count) captures a variable by reference so the closure and outer scope share its storage. That can be useful for a deliberate counter, but it introduces a side effect that callers must understand. Prefer returning results when the transformation can remain independent. Shared mutation makes invocation order matter and can complicate retries.
Capturing an object by value still stores a reference to that object instance. Mutating the object's properties can therefore be visible outside the closure. By-value capture is not deep immutability. If you need a snapshot, design an immutable value or clone appropriately rather than assuming use performs a complete copy of the object graph.
Callback contracts and exceptions
A higher-order operation should state how often and with which arguments it invokes a callback. It should also define what it does with the result. A predicate usually returns bool, a comparator returns an integer ordering result, and a mapper returns a transformed value. These contracts differ even though all use callables.
Exceptions from a callback normally propagate through the operation unless it catches them. Decide whether one bad item should stop a batch or be recorded as an item-level failure. Do not silently catch every Throwable and keep going when that would hide corrupted state. A callback error is still an error in application logic or data.
Avoid expensive hidden work in callbacks used many times. A sort comparator may run repeatedly, so it should not perform a database query for every comparison. Precompute validated sort fields or let the database order the result. A simple-looking closure can otherwise create a large amount of repeated I/O.
PHP Callback Functions and Anonymous Functions Examples
Each example shows the code, the output it produces and what each part does.
Transform values with an anonymous function
The closure is called once for each value and returns the transformed price. It does not need to know the entire input list. The transformation creates a result array instead of changing the original prices. This separation makes the callback easy to reason about in isolation.
<?php
$prices = [10, 20, 30];
$discounted = array_map(function (int $price): int {
return $price - 2;
}, $prices);
echo implode(',', $discounted) . PHP_EOL;8,18,28Observe the time of capture
The closure captured A before the outer variable changed. Reference capture would make the output follow the shared variable instead. Choose based on the intended lifetime: a formatter configured at creation often wants a stable value, while a deliberate shared counter may require a reference.
<?php
$prefix = 'A';
$label = function (string $value) use ($prefix): string {
return $prefix . ':' . $value;
};
$prefix = 'B';
echo $label('pen') . PHP_EOL;A:penCommon PHP Callback Functions and Anonymous Functions Mistakes
Letting visitors choose arbitrary function names
Do not take an unchecked request parameter and call the function with that name. PHP includes filesystem, process and network capabilities that your endpoint did not intend to expose. If users may select a transformation, map approved short names to known callbacks and reject every other name.
Also avoid capturing more state than needed. A closure that captures a large service object and several mutable arrays can conceal dependencies. A named function or dedicated object may be clearer when behavior grows. The anonymous functions manual and callable reference document supported forms and scope rules.
PHP Callback Functions and Anonymous Functions in Real Projects
Practical task: format approved labels
Write a function that receives a list of strings and a formatter callable, then returns one joined display line. The formatter contract is one string in and one string out. The example supplies an anonymous function that adds square brackets. The loop makes the call contract visible without depending on a particular array API.
<?php
function labelLine(array $labels, callable $formatter): string {
$formatted = [];
foreach ($labels as $label) {
$formatted[] = $formatter($label);
}
return implode(' ', $formatted);
}
$brackets = function (string $label): string {
return '[' . $label . ']';
};
echo labelLine(['Pen', 'Book'], $brackets) . PHP_EOL;[Pen] [Book]The operation owns traversal and joining; the callback owns one label's appearance. Try passing strtoupper(...) on PHP 8.1 or later to reuse a known built-in as a first-class callable. If labels come from requests, validate that each item is a string before this function runs. When the line is displayed in HTML, escape the final text for that context.
PHP Callback Functions and Anonymous Functions FAQ
Are all callbacks anonymous?
No. Named functions, object methods and invokable objects can be callbacks. Anonymous functions are one convenient form.
Why is my outer variable unavailable?
An ordinary closure needs a use clause for selected local variables. Arrow functions have automatic by-value capture.
Does callable validate the return value?
It validates callability, not the full behavioral contract. Return types on the callback and documentation help express that contract.
When should I use a named function?
When behavior is reused, substantial or deserves a discoverable name. A short one-off transformation can remain a closure.
Can a callback access $this?
A nonstatic closure created in an object context can be bound to that object. A static closure does not bind $this, which can make independence explicit.
PHP Callback Functions and Anonymous Functions Exercises
Answer each one and check it instantly. If you get stuck, open the hint before the answer.
Visitors can choose uppercase or brackets formatting. What is the safest callback selection design?
PHP Callback Functions and Anonymous Functions Quiz
2 questions to check what you learned.
What does a callback supply to array_map()?
- A database connection automatically
- A new PHP namespace
- The transformation for each item
What does use ($prefix) do for an ordinary closure?
- Captures the selected outer value by value
- Makes every variable globally writable
- Deletes the outer variable