🤳🏿 🤞🏻 💨 PHP में क्लोजर का उपयोग करना 🚉 👨🏽‍🚒 🚼

PHP 5.3 क्लोजर का परिचय इसके मुख्य नवाचारों में से एक है, और हालांकि रिलीज के कई साल बीत चुके हैं, फिर भी इस भाषा की सुविधा का उपयोग करने का कोई मानक अभ्यास नहीं है। इस लेख में, मैंने पीएचपी में क्लोजर का उपयोग करने के लिए सभी सबसे दिलचस्प संभावनाओं को इकट्ठा करने की कोशिश की।

शुरू करने के लिए, विचार करें कि यह क्या है - एक बंद और PHP में इसकी विशेषताएं क्या हैं।

$g = 'test'; $c = function($a, $b) use($g){ echo $a . $b . $g; }; $g = 'test2'; var_dump($c); /* object(Closure)#1 (2) { ["static"]=> array(1) { ["g"]=> string(4) "test" } ["parameter"]=> array(2) { ["$a"] => string(10) "" ["$b"]=> string(10) "" } } */

जैसा कि आप देख सकते हैं, लैम्बडा फ़ंक्शन की तरह एक क्लोजर, क्लोजर क्लास का एक ऑब्जेक्ट है, जो पारित मापदंडों को संग्रहीत करता है। ऑब्जेक्ट को फ़ंक्शन के रूप में कॉल करने के लिए, PHP5.3 में __inoke मैजिक विधि शुरू की गई थी।

 function getClosure() { $g = 'test'; $c = function($a, $b) use($g){ echo $a . $b . $g; }; $g = 'test2'; return $c; } $closure = getClosure(); $closure(1, 3); //13test getClosure()->__invoke(1, 3); //13test

उपयोग निर्माण का उपयोग करते हुए, हम पैरेंट स्कोप से लैम्बडा फंक्शन के लोकल स्कोप के वेरिएबल को वारिस करते हैं।
वाक्य विन्यास सरल और सीधा है। वेब अनुप्रयोगों के विकास में ऐसी कार्यक्षमता का उपयोग पूरी तरह से स्पष्ट नहीं है। मैंने भाषा की नई विशेषताओं का उपयोग करते हुए कई आधुनिक रूपरेखाओं के कोड को देखा और उनके विभिन्न अनुप्रयोगों को एक साथ लाने का प्रयास किया।

कॉलबैक फ़ंक्शन

अनाम कार्यों का सबसे स्पष्ट उपयोग उन्हें कॉलबैक के रूप में उपयोग करना है। PHP में कई मानक कार्य हैं जो कॉलबैक प्रकार या इसके समानार्थक कॉल योग्य को PHP 5.4 में स्वीकार करते हैं। सबसे लोकप्रिय हैं array_filter, array_map, array_reduce। Array_map फ़ंक्शन का उपयोग सरणी तत्वों के पुनरावृत्ति प्रसंस्करण के लिए किया जाता है। सरणी के प्रत्येक तत्व पर कॉलबैक फ़ंक्शन लागू किया जाता है और परिणामी सरणी को परिणाम के रूप में लौटाया जाता है। मुझे तुरंत अंतर्निहित फ़ंक्शन का उपयोग करके एक लूप में पारंपरिक सरणी प्रसंस्करण के प्रदर्शन की तुलना करने की इच्छा थी। आइए प्रयोग करते हैं।

 $x = range(1, 100000); $t = microtime(1); $x2 = array_map(function($v){ return $v + 1; }, $x); //Time: 0.4395 //Memory: 22179776 //--------------------------------------- $x2 = array(); foreach($x as $v){ $x2[] = $v + 1; } //Time: 0.0764 //Memory: 22174788 //--------------------------------------- function tr($v){ return $v + 1; } $x2 = array(); foreach($x as $v){ $x2[] = tr($v); } //Time: 0.4451 //Memory: 22180604

जैसा कि आप देख सकते हैं, बड़ी संख्या में फ़ंक्शन कॉल का ओवरहेड प्रदर्शन में ध्यान देने योग्य गिरावट देता है, जिसे उम्मीद की जानी है। यद्यपि परीक्षण सिंथेटिक है, बड़े सरणियों के प्रसंस्करण का कार्य अक्सर उठता है, और इस मामले में, डेटा प्रसंस्करण कार्यों का अनुप्रयोग वह स्थान बन सकता है जो आपके आवेदन को काफी धीमा कर देगा। सावधान रहें। फिर भी, आधुनिक अनुप्रयोगों में इस दृष्टिकोण का उपयोग अक्सर किया जाता है। यह आपको कोड को अधिक संक्षिप्त बनाने की अनुमति देता है, खासकर अगर हैंडलर को कहीं और घोषित किया जाता है, और जब बुलाया नहीं जाता है।

अनिवार्य रूप से, इस संदर्भ में, अनाम फ़ंक्शन का उपयोग किसी फ़ंक्शन या कॉलबैक सरणी के स्ट्रिंग नाम को पास करने के पुराने तरीके से अलग नहीं है, एक विशेषता के अपवाद के साथ - अब हम क्लोजर का उपयोग कर सकते हैं, अर्थात, फ़ंक्शन बनाते समय स्केबल्स को गुंजाइश से बचा सकते हैं। डेटाबेस में उन्हें जोड़ने से पहले डेटा की एक सरणी को संसाधित करने के एक उदाहरण पर विचार करें।

 //  . $quoter = function($v) use($pdo){ return $pdo->quote($v);//    ,    :-) } $service->register('quoter', $quoter); … //-    //      PDO $data = array(...);//  $data = array_map($this->service->getQuoter(), $data); //   .

फ़िल्टरिंग के लिए अनाम फ़ंक्शन का उपयोग करना बहुत सुविधाजनक है।

 $x = array_filter($data, function($v){ return $v > 0; }); //vs $x = array(); foreach($data as $v) { if($v > 0){$x[] = $v} }

घटनाक्रम।

क्लोजर इवेंट हैंडलर के रूप में आदर्श हैं। उदाहरण के लिए

 //-   . $this->events->on(User::EVENT_REGISTER, function($user){ //      .. }); $this->events->on(User::EVENT_REGISTER', function($user){ // email  . }); //    $this->events->trigger(User::EVENT_REGISTER, $user);

ईवेंट हैंडलर में तर्क निकालना, एक ओर, कोड क्लीनर बनाता है, दूसरी ओर, त्रुटियों की खोज को जटिल करता है - कभी-कभी सिस्टम का व्यवहार एक ऐसे व्यक्ति के लिए अप्रत्याशित हो जाता है जो यह नहीं जानता कि वर्तमान में कौन से हैंडलर लटकाए गए हैं।

मान्यता

क्लोज़र अनिवार्य रूप से एक चर में कुछ तर्क को संरक्षित करते हैं जो स्क्रिप्ट के चलने के रूप में निष्पादित या नहीं किया जा सकता है। सत्यापनकर्ताओं को लागू करने के लिए आपको यही चाहिए:

 $notEmpty = function($v){ return strlen($v) > 0 ? true : “    ”; }; $greaterZero = function($v){ return $v > 0 ? true : “    ”; }; function getRangeValidator($min, $max){ return function($v) use ($min, $max){ return ($v >= $min && $v <= $max) ? true : “    ”; }; }

बाद के मामले में, हम एक उच्च-क्रम फ़ंक्शन का उपयोग करते हैं जो एक और फ़ंक्शन लौटाता है - पूर्वनिर्धारित मूल्य सीमाओं के साथ एक सत्यापनकर्ता। उदाहरण के लिए, वैलिडेटर्स का उपयोग किया जा सकता है।

 class UserForm extends BaseForm{ public function __constructor() { $this->addValidator('email', Validators::$notEmpty); $this->addValidator('age', Validators::getRangeValidator(18, 55)); $this->addValidator('custom', function($v){ //some logic }); } /** *    . */ public function isValid() { … $validationResult = $validator($value); if($validationResult !== true){ $this->addValidationError($field, $validationResult); } … } }

रूपों का उपयोग करना एक उत्कृष्ट उदाहरण है। सामान्य वर्ग, मॉडल आदि के बसने और पाने वालों में वैधता का उपयोग किया जा सकता है। सच है, घोषणात्मक सत्यापन को अच्छा अभ्यास माना जाता है, जब नियमों को कार्यों के रूप में नहीं वर्णित किया जाता है, लेकिन कॉन्फ़िगरेशन के दौरान नियमों के रूप में, हालांकि, कभी-कभी यह दृष्टिकोण बहुत उपयोगी होता है।

भाव

क्लोजर के लिए सिम्फनी का बहुत दिलचस्प उपयोग है। ExprBuilder वर्ग एक इकाई को परिभाषित करता है जो फॉर्म के अभिव्यक्तियों को बनाने की अनुमति देता है

 ... ->beforeNormalization() ->ifTrue(function($v) { return is_array($v) && is_int(key($v)); }) ->then(function($v) { return array_map(function($v) { return array('name' => $v); }, $v); }) ->end() ...

सिम्फनी में, जैसा कि मैं इसे समझता हूं, यह एक आंतरिक वर्ग है जिसका उपयोग नेस्टेड कॉन्फ़िगरेशन सरणियों के लिए प्रसंस्करण बनाने के लिए किया जाता है (मुझे सही करें, यदि सही नहीं है)। एक दिलचस्प विचार श्रृंखला के रूप में अभिव्यक्तियों का कार्यान्वयन है। सिद्धांत रूप में, इस रूप में अभिव्यक्तियों का वर्णन करने वाले वर्ग को लागू करना काफी संभव है:

 $expr = new Expression(); $expr ->if(function(){ return $this->v == 4;}) ->then(function(){$this->v = 42;}) ->else(function(){}) ->elseif(function(){}) ->end() ->while(function(){$this->v >=42}) ->do(function(){ $this->v --; }) ->end() ->apply(function(){/*Some code*/}); $expr->v = 4; $expr->exec(); echo $expr->v;

आवेदन, ज़ाहिर है, प्रयोगात्मक है। वास्तव में, यह कुछ एल्गोरिथ्म का एक रिकॉर्ड है। इस तरह के एक कार्यात्मक का कार्यान्वयन बल्कि जटिल है - एक अभिव्यक्ति को आदर्श रूप से संचालन के एक पेड़ को संग्रहीत करना चाहिए। दिलचस्प अवधारणा, शायद कहीं ऐसा डिज़ाइन उपयोगी होगा।

मार्ग

कई मिनी-फ्रेमवर्क में, राउटिंग अब गुमनाम फ़ंक्शंस पर काम करती है।

 App::router('GET /users', function() use($app){ $app->response->write('Hello, World!'); });

आरामदायक पर्याप्त और संक्षिप्त।

कैशिंग

एक हब पर यह पहले से ही चर्चा में था, फिर भी।

 $someHtml = $this->cashe->get('users.list', function() use($app){ $users = $app->db->table('users)->all(); return $app->template->render('users.list', $isers); }, 1000);

यहां, प्राप्त विधि कुंजी 'users.list' का उपयोग करके कैश की वैधता की जांच करती है और यदि यह मान्य नहीं है, तो यह डेटा के लिए फ़ंक्शन तक पहुंचता है। तीसरा पैरामीटर डेटा भंडारण की अवधि निर्धारित करता है।

ऑन-डिमांड इनिशियलाइज़ेशन

मान लीजिए हमारे पास एक मेलर सेवा है जिसे हम कुछ तरीकों से कहते हैं। उपयोग करने से पहले, इसे कॉन्फ़िगर किया जाना चाहिए। हर बार इसे आरंभ करने के लिए नहीं, हम आलसी वस्तु निर्माण का उपयोग करेंगे।

 //-   . $service->register('Mailer', function(){ return new Mailer('user', 'password', 'url'); }); //-   $this->service('Mailer')->mail(...);

ऑब्जेक्ट का आरंभीकरण पहले उपयोग से पहले ही होगा।

वस्तु व्यवहार में परिवर्तन

कभी-कभी किसी स्क्रिप्ट के निष्पादन के दौरान वस्तुओं के व्यवहार को ओवरराइड करना उपयोगी होता है - एक विधि जोड़ें, पुराने को ओवरराइड करें, आदि। यहां बंद करने से हमें मदद मिलेगी। PHP5.3 में, आपको इसके लिए विभिन्न वर्कअराउंड का उपयोग करना था।

 class Base{ public function publicMethod(){echo 'public';} private function privateMethod(){echo 'private';} //       . public function __call($name, $arguments) { if($this->$name instanceof Closure){ return call_user_func_array($this->$name, array_merge(array($this), $arguments)); } } } $b = new Base; //   $b->method = function($self){ echo 'I am a new dynamic method'; $self->publicMethod(); //        }; $b->method->__invoke($b); //    $b->method(); //      //call_user_func($b->{'method'}, $b); //

सिद्धांत रूप में, आप पुरानी पद्धति को फिर से परिभाषित कर सकते हैं, लेकिन केवल अगर इसे समान तरीके से परिभाषित किया गया हो। बहुत सुविधाजनक नहीं है। इसलिए, PHP 5.4 में, किसी वस्तु के साथ एक बंद को जोड़ना संभव हो गया।

 $closure = function(){ return $this->privateMethod(); } $closure->bindTo($b, $b); //     $closure();

बेशक, वस्तु का संशोधन काम नहीं करता था, हालांकि, निजी कार्यों और संपत्तियों तक पहुंच बंद हो जाती है।

डेटा एक्सेस विधियों में डिफ़ॉल्ट पैरामीटर के रूप में पास करें

GET सरणी से मान प्राप्त करने का एक उदाहरण। यदि यह अनुपस्थित है, तो फ़ंक्शन को कॉल करके मान प्राप्त किया जाएगा।

 $name = Input::get('name', function() {return 'Fred';});

उच्च आदेश कार्य

सत्यापनकर्ता बनाने का एक उदाहरण पहले से ही है। मैं लिथियम फ्रेमवर्क से एक उदाहरण दूंगा

 /** * Writes the message to the configured cache adapter. * * @param string $type * @param string $message * @return closure Function returning boolean `true` on successful write, `false` otherwise. */ public function write($type, $message) { $config = $this->_config + $this->_classes; return function($self, $params) use ($config) { $params += array('timestamp' => strtotime('now')); $key = $config['key']; $key = is_callable($key) ? $key($params) : String::insert($key, $params); $cache = $config['cache']; return $cache::write($config['config'], $key, $params['message'], $config['expiry']); }; }

विधि एक क्लोजर देता है, जो तब कैश को संदेश लिखने के लिए उपयोग किया जा सकता है।

टेम्प्लेट पास करें

कभी-कभी न केवल टेम्पलेट को डेटा स्थानांतरित करना सुविधाजनक होता है, बल्कि, उदाहरण के लिए, एक कॉन्फ़िगर किया गया फ़ंक्शन जिसे किसी भी मान को प्राप्त करने के लिए टेम्पलेट कोड से बुलाया जा सकता है।

 //  $layout->setLink = function($setId) use ($userLogin) { return '/users/' . $userLogin . '/set/' . $setId; }; //  <a href=<?=$this->setLink->__invoke($id);?>>Set name</a>

इस मामले में, उपयोगकर्ता संस्थाओं के कई लिंक टेम्पलेट में उत्पन्न किए गए थे, और इन लिंक के पते में उनका लॉगिन दिखाई दिया।

पुनरावर्ती बंद परिभाषा

अंत में, कैसे पुनरावर्ती बंद को परिभाषित किया जा सकता है। ऐसा करने के लिए, उपयोग करने के लिए एक क्लोजर संदर्भ पास करें, और इसे कोड में कॉल करें। पुनरावृत्ति को समाप्त करने के बारे में मत भूलना

 $factorial = function( $n ) use ( &$factorial ) { if( $n == 1 ) return 1; return $factorial( $n - 1 ) * $n; }; print $factorial( 5 );

कई उदाहरणों में तना हुआ दिखता है। कितने साल उनके बिना रहे - और कुछ भी नहीं। हालांकि, कभी-कभी क्लोजर लागू करना पीएचपी के लिए पर्याप्त स्वाभाविक है। इस सुविधा का कुशल उपयोग कोड को अधिक पठनीय बना देगा और प्रोग्रामर की दक्षता में वृद्धि करेगा। आपको बस अपनी सोच को नए प्रतिमान में थोड़ा सा समायोजित करने की जरूरत है और सब कुछ ठीक हो जाएगा। सामान्य तौर पर, मैं यह तुलना करने की सलाह देता हूं कि इस तरह की चीजों को अन्य भाषाओं जैसे पायथन में कैसे उपयोग किया जाता है। मुझे उम्मीद है कि किसी ने यहां अपने लिए कुछ नया पाया। और निश्चित रूप से, अगर किसी को बंद होने के किसी अन्य दिलचस्प अनुप्रयोगों को पता है, तो मैं वास्तव में आपकी टिप्पणियों के लिए तत्पर हूं। धन्यवाद!

PHP में क्लोजर का उपयोग करना