🌁 ✋🏻 🚭 PHP में लक्षण और बेनामी फ़ंक्शंस। नीम हकीम! 👨🏿‍🚒 👨🏼‍🎤 👨🏿‍🤝‍👨🏻

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

प्रस्तावना

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

लेकिन, अगर जावा में, एक सांख्यिकीय रूप से टाइप की गई भाषा के रूप में, यह समझ में आता है, क्योंकि यह आपको संकलन चरण में त्रुटियों की एक निश्चित सीमा की पहचान करने की अनुमति देता है, तो गतिशील रूप से टाइप किए गए PHP में इन सभी इशारों में क्या बिंदु है? शायद हम पूरी तरह से अनावश्यक चीजों के बारे में बहुत अधिक चिंता करते हैं? क्या यह वास्तव में हमारे लिए प्राप्त वस्तुओं के डैड्स, दादी या चचेरे भाई के बारे में पूछताछ करने के लिए आवश्यक है, जब संक्षेप में हम केवल इस बात में रुचि रखते हैं कि क्या वस्तु को हमारी आवश्यकता है?

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

कुछ समय पहले, अनाम फ़ंक्शंस (5.3) PHP में दिखाई दिए, और मैंने सोचा: "बुरा नहीं है! लेकिन बहुत उपयोगी नहीं है। ” तब (5.4) लक्षण PHP में दिखाई दिए, और मुझे एहसास हुआ कि समय आ गया था। चलिए अंत में एक उदाहरण पर चलते हैं और देखते हैं कि PHP को क्या पेशकश करनी है।

समस्या का बयान

तो, चलो अनाम कार्यों के साथ संयोजन में लक्षण का उपयोग करते हैं। किस पर ट्रेन करें? खैर, संग्रह मेरे दिमाग में आए, इसलिए हम उन पर प्रशिक्षण देंगे। पहले, आइए इस बारे में सोचें कि हम क्या चाहते हैं और इसे प्राप्त करने के तरीके क्या हैं।

तो, संग्रह पर क्या कार्रवाई की जा सकती है। ठीक है, उदाहरण के लिए, हम संग्रह के अधिकतम और न्यूनतम तत्व, या ऐसे तत्व पा सकते हैं जो एक निश्चित स्थिति को संतुष्ट करते हैं; हम मूल संग्रह आदि के प्रत्येक तत्व पर कुछ ऑपरेशन (मानचित्र) लागू करके एक नया संग्रह प्राप्त कर सकते हैं ... इन विधियों के सेट को सीधे एक प्रकार कहा जाता है।

हमें संग्रह से क्या चाहिए ताकि हम इन विधियों को लागू कर सकें? केवल एक चीज: हमें संग्रह के तत्वों पर पुनरावृति करने में सक्षम होना चाहिए। चलो इस आवश्यक कार्यक्षमता को एक अनुबंध कहते हैं ।

हम इस अनुबंध को कैसे लागू कर सकते हैं? दो विकल्प हैं:

मानक दृष्टिकोण जब हम खुद पर चलना चाहते हैं। यानी क्लाइंट संग्रह से एक पुनरावृत्ति प्राप्त करता है और इस संग्रह को बायपास करने के लिए इसका उपयोग करता है।
हम मानते हैं कि संग्रह बेहतर तरीके से खुद को पुनरावृत्त करना जानता है, और संग्रह के माध्यम से मोटे तौर पर चलने के बजाय, पिछले संस्करण में, हम विनम्रता से इसे चारों ओर जाने के लिए कहते हैं , पुनरावृत्ति के लिए कुछ तर्क का संचार करते हैं।

दोनों दृष्टिकोण अच्छे हैं (शायद पहला दूसरे की तुलना में थोड़ा अधिक लचीला है), लेकिन मैं दृष्टिकोण संख्या 2 को चुनूंगा, क्योंकि, सबसे पहले, यह मेरे उद्देश्यों को बेहतर ढंग से पूरा करेगा, और दूसरी बात, क्योंकि मैं ऐसा चाहता था।

कार्यान्वयन

उदाहरण शुरू करने से पहले, मैं सुझाव देता हूं कि आप इस मामले के लिए GitHub पर विशेष रूप से तैयार किए गए भंडार से कोड डाउनलोड करें, जैसा कि लेख में लिस्टिंग स्पष्टता के लिए छंटनी की जाएगी।

तो, चलिए, ऊपर वर्णित विचारों द्वारा निर्देशित, हमारे प्रकार लिखें।

लिस्टिंग: संग्रह \ Enumerable

namespace Collections; trait Enumerable { /**     ,  $block     **/ abstract public function each(\Closure $block); public function findAll(\Closure $predicate) { $result = new FancyArray(); $this->each(function($el) use ($predicate, &$result) { if ($predicate($el)) { $result[] = $el; } }); return $result; } public function map(\Closure $block) { $result = new FancyArray(); $this->each(function($el) use ($block, &$result) { $processed = $block($el); $result[] = $processed; }); return $result; } /**     **/ }

अपने आप से, यह बहुत अधिक मूल्य नहीं रखता है, इसलिए हमें एक संग्रह की आवश्यकता है जहां इसे शामिल किया जा सकता है। आइए एक उदाहरण के रूप में एक साधारण सरणी का उपयोग करते हुए इस संग्रह को लागू करें:

लिस्टिंग: संग्रह / FancyArray

 namespace Collections; class FancyArray implements \ArrayAccess, \Countable { protected $container; function __construct($initial = array()) { if (is_array($initial)) { $this->container = $initial; } else if ($initial instanceof FancyArray) { $this->container = $initial->toArray(); } } public function offsetExists($offset) { return isset($this->container[$offset]); } public function offsetGet($offset) { return isset($this->container[$offset]) ? $this->container[$offset] : null; } public function offsetSet($offset, $value) { if (is_null($offset)) { $this->container[] = $value; } else { $this->container[$offset] = $value; } } public function offsetUnset($offset) { unset($this->container[$offset]); } public function toArray() { return $this->container; } public function count() { return count($this->container); } }

अब हमारे पास एक सरणी है, यह केवल संग्रह \ Enumerable के प्रकार को इसमें शामिल करने और अनुबंध को लागू करने के लिए बनी हुई है:

 namespace Collections; class FancyArray implements \ArrayAccess, \Countable { use Enumerable; ... ... ... ... /** * Calls $block for every element of a collection * @param callable $block */ public function each(\Closure $block) { foreach ($this->container as $el) { $block($el); } } }

जैसा कि आप देख सकते हैं, सब कुछ बहुत मामूली है, लेकिन अब हम कर सकते हैं, उदाहरण के लिए, ऐसी चीजें (और इसके लिए हमें केवल कुछ पंक्तियों की आवश्यकता है):

 $a = new FancyArray([1, 2, 3, 4]); $res = $a->map(function($el) { return $el*$el; }); // [1, 4, 9, 16] $res->reduce(0, function($initial, $el) { return $initial + $el; })); // 30

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

 namespace IO; class FancyFile extends \SplFileObject { use \Collections\Enumerable; public function each(\Closure $block) { $this->fseek(0); while ($this->valid()) { $line = $this->fgets(); $block($line); } } }

हमने विशेषता को चालू किया, अनुबंध को लागू किया, और अब हम उदाहरण के लिए, एक विषम-लंबाई की फ़ाइल की कुल लंबाई की गणना निम्नानुसार कर सकते हैं (यदि हमें कभी भी ^ _ ^ की आवश्यकता है):

 $obj = new FancyFile(<filename>); $res = $obj ->select(function($el) { return strlen(trim($el)) % 2 == 1; }) ->map(function($el) { return strlen(trim($el)); }) ->reduce(0, function($initial, $el) { return $initial + $el; });

ये बातें हैं, सज्जनों।

निष्कर्ष

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

संदर्भ

प्रकारों के बारे में पोस्ट करें - habrahabr.ru/post/130000
बतख टाइपिंग के बारे में - en.wikipedia.org/wiki/Duck_typing
लेख से कोड के साथ भंडार - github.com/ArtemPyanykh/php_fancy_collections

पुनश्च

यदि आपके पास समय है, तो कोड के साथ खेलने का प्रयास करें। उदाहरण के लिए, प्रत्येक प्रारूप के कलेक्शंस \ Enumerable पद्धति को लागू करें:

 $a->eachWithIndex(function($el, $idx) { echo $el; echo $idx; });

या संग्रह \ Enumerable # खोज विधि में गैर-स्थानीय संक्रमण की समस्या को हल करने का प्रयास करें (जैसे ही हमें पहला तत्व मिलता है जो स्थिति को संतुष्ट करता है, हम पुनरावृत्ति को रोक सकते हैं और इसे वापस कर सकते हैं)।
यदि आप एक अच्छा समाधान के साथ आते हैं या सिर्फ कुछ दिलचस्प लागू करते हैं, तो कृपया एक अनुरोध करें।