closure என்பது ஒரு anonymous function (பெயரற்ற function, ஒரு variable இல் சேமிக்கப்பட்டது). callable என்பது PHP எந்த function ஐ call செய்ய முடியுமோ அது — closures, named functions, methods, அல்லது invokable objects. இவை functional-style programming, callbacks, மற்றும் higher-order functions ஐ செயல்படுத்தும்.
= {
* ;
};
();
= * ;
();
ஒரு closure என்பது ஒரு anonymous function ஆகும், நீங்கள் சேமித்து அதை வெளியே அனுப்பலாம். arrow function (fn) என்பது ஒரு concise form ஆகும், அது வெளிப்புற 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 இல் வெளிப்புற 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 ஐ ஏற்கிறது — higher-order functions (array_map/array_filter/usort மற்றும் callback-based APIs) ஐ செயல்படுத்துகிறது.
Closures மற்றும் callables என்பவை முக்கியமான PHP features ஆகும், இவை functional-style programming, callbacks, மற்றும் higher-order functions ஐ செயல்படுத்தும் — இந்த patterns ஆধুனிக PHP இல் அடிக்கடி பயன்படுத்தப்படுகிறது.
Closures (anonymous functions, variables இல் சேமிக்கப்பட்டவை) மற்றும் குறிப்பாக arrow function (fn, வெளிப்புற 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 அவற்றை எப்படி ஏற்கிறது என்பதை அறிவது clean, functional-style PHP ஐ எழுத மற்றும் callbacks ஐ எடுக்கும் பல framework மற்றும் standard-library APIs ஐ பயன்படுத்த (route handlers, collection methods, middleware) முக்கியம்.
Closures மற்றும் callables என்பவை expressive modern PHP க்கு அடிப்படை — இவை data transformation, filtering, sorting, மற்றும் callback patterns ஐ concise மற்றும் readable ஆக்குகிறது — எனவே இவற்றை master செய்வது, குறிப்பாக convenient arrow-function syntax மற்றும் capture-by-use-vs-auto distinction, productive PHP development க்கான practical, frequently-applied knowledge ஆகும்.