Une closure est une fonction anonyme (une fonction sans nom, stockée dans une variable). Un callable est tout ce que PHP peut appeler comme une fonction — closures, fonctions nommées, méthodes, ou objets invocables. Ils permettent la programmation de style fonctionnel, les callbacks, et les fonctions d'ordre supérieur.
= {
* ;
};
();
= * ;
();
Une closure est une fonction anonyme que vous pouvez stocker et transmettre. La arrow function (fn) est une forme concise qui capture automatiquement les variables extérieures.
$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;
La différence clé : les closures traditionnelles ont besoin d'une clause use explicite pour capturer les variables extérieures, tandis que les arrow functions les capturent automatiquement — un grand avantage pour les courts 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 est un type hint pour les paramètres qui acceptent n'importe quel callable — permettant les fonctions d'ordre supérieur (fonctions prenant des fonctions), la base de array_map/array_filter/usort et les APIs basées sur des callbacks.
Les closures et les callables sont des fonctionnalités PHP importantes qui permettent la programmation de style fonctionnel, les callbacks, et les fonctions d'ordre supérieur — des patterns utilisés constamment en PHP moderne.
Comprendre les closures (fonctions anonymes stockées dans des variables) et surtout la arrow function (fn, qui capture automatiquement les variables extérieures, contrairement aux closures traditionnelles qui nécessitent une clause use explicite) est une connaissance quotidienne, car ce sont le moyen naturel d'écrire les courtes fonctions en ligne passées aux fonctions de tableau (array_map/array_filter/array_reduce), aux tris personnalisés (usort), aux gestionnaires d'événements, et aux APIs basées sur des callbacks.
Savoir ce qui compte comme un callable (fonctions nommées, méthodes, méthodes statiques, closures, objets invocables) et comment les fonctions d'ordre supérieur les acceptent est essentiel pour écrire un PHP clean et de style fonctionnel et pour utiliser les nombreuses APIs de framework et de bibliothèque standard qui prennent des callbacks (gestionnaires de routes, méthodes de collection, middleware).
Les closures et les callables sont fondamentaux pour un PHP moderne expressif — ils rendent les transformations de données, le filtrage, le tri, et les patterns de callback concis et lisibles — donc maîtriser ces concepts, en particulier la pratique syntaxe arrow-function et la distinction entre capture-par-use-vs-auto, est une connaissance pratique et fréquemment appliquée pour un développement PHP productif.