PHP Anonymous Functions
In this page:
What is an Anonymous Function?
An anonymous function (a closure) is defined without ever being given a name of its own — instead of calling it by name later, you typically assign it directly to a variable or hand it straight to another function as an argument.
Example: What is an Anonymous Function?
<?php
$greet = function ($name) {
echo "Hello, $name!";
};
$greet("Alice");
?>Login to try C/C++/Java/PHP code in the editor
Using Closures as Callbacks
Built-in array functions like array_filter() and usort() expect a callback to tell them exactly how to filter or compare elements. An anonymous function defined right at the call site is a natural fit here, since that logic is usually one-off and doesn't need a name of its own elsewhere in the codebase.
Example: Using Closures as Callbacks
<?php
$numbers = [1, 2, 3, 4, 5];
$even = array_filter($numbers, function ($n) {
return $n % 2 === 0;
});
print_r($even);
?>Login to try C/C++/Java/PHP code in the editor
The 'use' Keyword
The use keyword lets a closure pull in variables from the scope it was defined in — without it, the closure has no access to anything outside its own parameter list, even variables that were clearly visible right where the closure was written.
Example: The 'use' Keyword
<?php
$tax = 0.1;
$addTax = function ($price) use ($tax) {
return $price + ($price * $tax);
};
echo $addTax(100);
?>Login to try C/C++/Java/PHP code in the editor
Type Hinting Callables
Declaring a parameter's type as callable (or specifically Closure) documents that a function expects to receive something it can invoke, and lets PHP enforce that at the call site rather than only discovering the mistake when the function tries to call a non-callable value.
Example: Type Hinting Callables
<?php
function apply(callable $fn, $value) {
return $fn($value);
}
echo apply(function ($x) { return $x * 2; }, 5);
?>Login to try C/C++/Java/PHP code in the editor
Closures and $this
A closure defined inside a class method automatically has access to $this, referring to the same object instance the enclosing method belongs to — letting the closure read or modify that object's properties and call its other methods just as the surrounding method could.
Example: Closures and $this
<?php
class Counter {
private $count = 0;
function makeIncrementer() {
return function () {
$this->count++;
return $this->count;
};
}
}
$counter = new Counter();
$increment = $counter->makeIncrementer();
echo $increment();
?>Login to try C/C++/Java/PHP code in the editor
Chapter Quiz — Complete all 10 topics to unlock
0/10 topics done
Complete these topics first: