closure అనేది anonymous function (పేరు లేని function, ఒక variable లో నిల్వ చేయబడింది). callable అనేది PHP ఏదైనా function గా call చేయగలిగిన వస్తువు — closures, named functions, methods, లేదా invokable objects. అవి functional-style programming, callbacks, మరియు higher-order functions లను సక్షమ చేస్తాయి.
= {
* ;
};
();
= * ;
();
A closure అనేది anonymous function మీరు నిల్వ చేసి చుట్టూ పంపగలిగే function. arrow function (fn) అనేది ఒక సంక్షిప్త రూపం ఇది outer variables లను స్వయంచాలకంగా capture చేస్తుంది.
$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;
ప్రధాన వ్యత్యాసం: traditional closures లు outer variables లను capture చేయడానికి explicit use clause అవసరం, అయితే arrow functions వాటిని స్వయంచాలకంగా capture చేస్తాయి — 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 అనేది parameters కోసం type hint ఇది ఏదైనా callable accept చేస్తుంది — higher-order functions (functions taking functions) సక్షమ చేస్తుంది, array_map/array_filter/usort మరియు callback-based APIs యొక్క ఆధారం.
Closures మరియు callables అనేవి functional-style programming, callbacks, మరియు higher-order functions లను సక్షమ చేసే ముఖ్యమైన PHP features — ఆధునిక PHP లో నిరంతరం ఉపయోగించిన నమూనాలు.
Closures (variables లో నిల్వ చేయబడిన anonymous functions) మరియు ముఖ్యంగా arrow function (fn, ఇది outer variables లను స్వయంచాలకంగా capture చేస్తుంది, traditional closures లాగా explicit use clause అవసరం లేకుండా) ను అర్థం చేసుకోవడం రోజువారీ జ్ఞానం, ఎందుకంటే అవి array functions (array_map/array_filter/array_reduce), custom sorts (usort), event handlers, మరియు callback-based APIs కు పంపిన short inline functions కోసం సహజ మార్గం.
callable లో ఏమి ఉందో తెలుసుకోవడం (named functions, methods, static methods, closures, invokable objects) మరియు higher-order functions ఆ వాటిని ఎలా accept చేస్తాయో తెలుసుకోవడం clean, functional-style PHP రాయడానికి మరియు route handlers, collection methods, middleware తీసుకున్న అనేక framework మరియు standard-library APIs లను ఉపయోగించడానికి కీలకం.
Closures మరియు callables ఎక్స్ప్రెసివ ఆధునిక PHP కు ప్రాథమిక — అవి data transformation, filtering, sorting, మరియు callback patterns లను సంక్షిప్తమైన మరియు చదవదగిన చేస్తాయి — కాబట్టి వాటిని నిపుణుడిగా చేసుకోవడం, ముఖ్యంగా convenient arrow-function syntax మరియు capture-by-use-vs-auto distinction, ఉత్పాదક PHP development కోసం ఆచరణాత్మక, ఎక్కువ వర్తించిన జ్ఞానం.