En closure är en anonym funktion (en funktion utan namn, lagrad i en variabel). En callable är allt som PHP kan anropa som en funktion — closures, namngivna funktioner, metoder eller anropbara objekt. De möjliggör funktionell programmering, callbacks och högre ordningens funktioner.
= {
* ;
};
();
= * ;
();
En closure är en anonym funktion som du kan lagra och skicka vidare. Arrow-funktionen (fn) är en kortfattad form som automatiskt fångar variabler från omgivningen.
$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;
Huvudskillnaden: traditionella closures behöver en explicit use-sats för att fånga variabler från omgivningen, medan arrow-funktioner fångar dem automatiskt — en stor bekvämlighet för korta 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 är en typ-hint för parametrar som accepterar vilken callable som helst — möjliggör högre ordningens funktioner (funktioner som tar funktioner), grunden för array_map/array_filter/usort och callback-baserade API:er.
Closures och callables är viktiga PHP-funktioner som möjliggör funktionell programmering, callbacks och högre ordningens funktioner — mönster som används konstant i modern PHP.
Att förstå closures (anonyma funktioner lagrade i variabler) och särskilt arrow-funktionen (fn, som automatiskt fångar variabler från omgivningen, till skillnad från traditionella closures som kräver en explicit use-sats) är vardagskunskap, eftersom de är det naturliga sättet att skriva de korta inline-funktioner som skickas till arrayfunktioner (array_map/array_filter/array_reduce), anpassade sorteringar (usort), event handlers och callback-baserade API:er.
Att veta vad som räknas som en callable (namngivna funktioner, metoder, statiska metoder, closures, anropbara objekt) och hur högre ordningens funktioner accepterar dem är nyckeln till att skriva ren, funktionell PHP och till att använda de många framework- och standardbiblioteks-API:er som tar callbacks (route handlers, collection-metoder, middleware).
Closures och callables är grundläggande för expressiv modern PHP — de gör datatransformation, filtrering, sortering och callback-mönster kortfattad och läsbar — så att bemästra dem, särskilt den bekväma arrow-function-syntaxen och skillnaden mellan fånga-via-use-vs-automatiskt, är praktisk, ofta använd kunskap för produktiv PHP-utveckling.