closure არის ანონიმური ფუნქცია (ფუნქცია ბез სახელის, ცვლადში შენახული). callable არის ყველაფერი, რაც PHP-ს შეუძლია ფუნქციად გამოიძახოს — closures, დასახელებული ფუნქციები, მეთოდები ან invokable ობიექტები. ისინი მოკერძოებს functional-style პროგრამირების, callbacks-ის და higher-order ფუნქციების გამოყენებას.
= {
* ;
};
();
= * ;
();
closure არის ანონიმური ფუნქცია, რომელიც შეგიძლია შენახო და გადაიტანო. arrow function (fn) არის მოკლე ფორმა, რომელიც ავტომატურად იჭერს გარე ცვლადებს.
$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;
მთავარი განსხვავება: ტრადიციული closures საჭიროებს გამოკვეთილი use პუნქტი გარე ცვლადების დასაჭერად, ხოლო arrow functions ისინი ავტომატურად იჭერენ — დიდი მოხერხებულობა მოკლე 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 არის ტიპის hint პარამეტრებისთვის, რომლებიც მიიღებენ ნებისმიერი callable-ს — მოკერძოებს higher-order functions (ფუნქციები, რომლებიც ღებულობენ ფუნქციებს), რომელიც ფუძეა array_map/array_filter/usort და callback-ზე დაფუძნებული APIs-ის.
Closures და callables არის მნიშვნელოვანი PHP ფიჩები, რომლებიც მოკერძოებს functional-style პროგრამირებას, callbacks-ს და higher-order ფუნქციებს — ნიმუშები, რომლებიც მუდმივად გამოიყენება თანამედროვე PHP-ში.
closures-ის (ანონიმური ფუნქციები, რომლებიც შენახულია ცვლადებში) და განსაკუთრებით arrow function-ის (fn, რომელიც ავტომატურად იჭერს გარე ცვლადებს, ზე განსხვავებით ტრადიციული closures-ის, რომლებიც საჭიროებენ გამოკვეთილი use პუნქტი) გაგება არის აკადემიური ცოდნა, რადგან ისინი ბუნებრივი გზაა მოკლე inline ფუნქციების დასაწერად, რომლებიც გადაიტანება array ფუნქციებში (array_map/array_filter/array_reduce), კასტომ sorts-ში (usort), event handlers-ში და callback-ზე დაფუძნებული APIs-ში.
იმის ცოდნა, რომ რა ითვლება callable-ად (დასახელებული ფუნქციები, მეთოდები, სტატიკური მეთოდები, closures, invokable ობიექტები) და როგორ ღებულობენ ისინი higher-order ფუნქციები, არის კლიუჩი სუფთა, functional-style PHP-ის დასაწერად და ბევრი framework და standard-library API-ის გამოსაყენებლად, რომლებიც იღებენ callbacks-ს (route handlers, collection methods, middleware).
closures და callables არის ფუნდამენტური ჩვენებითი თანამედროვე PHP-ში — ისინი ხდიან მონაცემების ტრანსფორმაციას, ფილტრაციას, სორტირებას და callback ნიმუშებს მოკლე და წაკითხვადი — ამიტომ მათი ოსტატობა, განსაკუთრებით მოხერხებული arrow-function სინტაქსი და capture-by-use-vs-auto განსხვავება, არის პრაქტიკული, ხშირად გამოყენებული ცოდნა პროდუქტიული PHP განვითარებისთვის.