A closure is an anonymous function (a function with no name, stored in a variable). A callable is anything PHP can call as a function — closures, named functions, methods, or invokable objects. They enable functional-style programming, callbacks, and higher-order functions.
= {
* ;
};
();
= * ;
();
A closure is an anonymous function you can store and pass around. The arrow function (fn) is a concise form that automatically captures outer variables.
$factor = 10;
// traditional closure — must explicitly import variables with `use`
$multiply = function (int $x) use ($factor): int {
return $x * $factor; // $factor captured by value
};
// arrow function — captures outer variables AUTOMATICALLY (no `use` needed)
$multiply = fn(int $x): int => $x * $factor;
The key difference: traditional closures need an explicit use clause to capture outer variables, while arrow functions capture them automatically — a major convenience for short callbacks.
// these are all callables, usable as callbacks:
'strlen' // a string naming a function
[$object, 'methodName'] // [object, method] array
['ClassName', 'staticMethod'] // [class, static method]
fn($x) => $x * 2 // a closure/arrow function
$invokableObject // an object with __invoke()
// used with higher-order functions:
array_map(fn($x) => $x * 2, [1, 2, 3]); // [2, 4, 6]
array_filter($users, fn($u) => $u->isActive()); // filter
usort($items, fn($a, $b) => $a->price <=> $b->price); // custom sort
callable is a type hint for parameters that accept any callable — enabling higher-order functions (functions taking functions), the basis of array_map/array_filter/usort and callback-based APIs.
Closures and callables are important PHP features that enable functional-style programming, callbacks, and higher-order functions — patterns used constantly in modern PHP.
Understanding closures (anonymous functions stored in variables) and especially the arrow function (fn, which auto-captures outer variables, unlike traditional closures that require an explicit use clause) is everyday knowledge, since they're the natural way to write the short inline functions passed to array functions (array_map/array_filter/array_reduce), custom sorts (usort), event handlers, and callback-based APIs.
Knowing what counts as a callable (named functions, methods, static methods, closures, invokable objects) and how higher-order functions accept them is key to writing clean, functional-style PHP and to using the many framework and standard-library APIs that take callbacks (route handlers, collection methods, middleware).
Closures and callables are fundamental to expressive modern PHP — they make data transformation, filtering, sorting, and callback patterns concise and readable — so mastering them, especially the convenient arrow-function syntax and the capture-by-use-vs-auto distinction, is practical, frequently-applied knowledge for productive PHP development.