कार्रवाई में जनरेटर

छोटा सा परिचय

बहुत पहले नहीं, मैंने खुद के लिए फैसला किया कि यह एक बड़ा ज्ञान अंतराल भरने का समय था और PHP के संस्करणों के बीच बदलाव के बारे में पढ़ने का फैसला किया, क्योंकि मैंने महसूस किया कि मैं 5.2 और 5.3 के बीच कहीं रहा और इस अंतर को किसी तरह समाप्त करने की आवश्यकता है। इससे पहले, मैं नाम स्थान, लक्षण आदि के बारे में पढ़ता हूं, लेकिन यह पढ़ने से परे नहीं है। और यहाँ मैंने जनरेटर पर ध्यान दिया, दस्तावेज़ीकरण पढ़ा, इस विषय पर हैबेरा के लेखों में से एक , और उसके बाद यह विचार आया कि - वे उनके बिना पहले कैसे रहते थे?

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

UPD1 : टिप्पणियों में बोले गए अस्पष्ट शब्दों को बदल दिया।
UPD2 : जबरन ब्रेक के साथ एक समाधान जोड़ा गया।

सिद्धांत

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

$f = fopen($file, 'r'); while ($line = fgets($f)) { doSomethingWithLine($line); } 

यह सामान्य उपाय है, यहां कुछ भी अजीब नहीं है। लेकिन क्या होगा अगर हमें कुछ और सार चाहिए? एक सार स्रोत से तार उत्पन्न कहते हैं। हां, आज यह एक फाइल हो सकती है, लेकिन कल हम तय करेंगे कि डेटाबेस या कुछ और एक बेहतर समाधान होगा।

अब हमारे पास इस समस्या को हल करने के दो तरीके हैं - हम एक सरणी या एक पुनरावृत्तिक लौटा सकते हैं। लेकिन सरणी को लौटाने में कई समस्याएं हैं: सबसे पहले, हम नहीं जानते कि हमें कितनी मेमोरी की आवश्यकता है (यदि हमारे पास 30 जीबी फ़ाइल है?), और दूसरी बात, शायद हम अपने स्रोत को एक सरणी के रूप में वर्णित करने में सक्षम नहीं होंगे (उदाहरण के लिए, हम डेटा का अंतहीन हिस्सा लौटाएं और अनुमान लगाने की कोशिश करें कि यह धारा कब समाप्त होगी, यदि आप एक ग्राहक हैं)।

इसलिए, पुनरावृत्तियाँ बनी हुई हैं। हमारा उदाहरण एक पुनरावृत्त के माध्यम से वर्णन करने के लिए बहुत सरल है। इसके अलावा, PHP में इसके लिए पहले से ही एक तैयार वर्ग है - SPLFileObject । लेकिन चलो इसे छोड़ दें और अपना खुद का कुछ लिखें।

 class FileIterator implements Iterator { protected $f; public function __construct($file) { $this->f = fopen($file, 'r'); if (!$this->f) throw new Exception(); } public function current() { return fgets($this->f); } public function key() { return ftell($this->f); } public function next() { } public function rewind() { fseek($this->f, 0); } public function valid() { return !feof($this->f); } } 

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

 class FileIterator implements Iterator { protected $f; protected $data; protected $key; public function __construct($file) { $this->f = fopen($file, 'r'); if (!$this->f) throw new Exception(); } public function __destruct() { fclose($this->f); } public function current() { return $this->data; } public function key() { return $this->key; } public function next() { $this->data = fgets($this->f); $this->key++; } public function rewind() { fseek($this->f, 0); $this->data = fgets($this->f); $this->key = 0; } public function valid() { return false !== $this->data; } } 

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

 function getLines($file) { $f = fopen($file, 'r'); if (!$f) throw new Exception(); while ($line = fgets($f)) { yield $line; } fclose($f); } 

बहुत आसान! हां, यह लगभग एक फ़ंक्शन के साथ पहला उदाहरण है, केवल एक अपवाद और उपज कीवर्ड दिखाई दिया।

तो यह कैसे काम करता है?

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

 foreach (getLines("someFile") as $line) { doSomethingWithLine($line); } 

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

 function doStuff() { $last = 0; $current = 1; yield 1; while (true) { $current = $last + $current; $last = $current - $last; yield $current; } } 

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

यह ध्यान दिया जाना चाहिए कि जनरेटर पुनरावृत्तियों के लिए एक विकल्प नहीं हैं। यह उन्हें प्राप्त करने का एक सरल तरीका है। Iterators अभी भी एक शक्तिशाली उपकरण हैं।

जटिल उदाहरण

हमें अपना ArrayObject बनाना होगा । इट्रेटर करने के बजाय, चलो जनरेटर के साथ थोड़ा सा चाल चलें। IteratorAggregate इंटरफ़ेस के लिए हमें केवल एक विधि की आवश्यकता है - getIterator ()। चूंकि जनरेटर एक वस्तु देता है जो पुनरावृत्ति को लागू करता है, हम इस पद्धति को ओवरराइड कर सकते हैं ताकि यह जनरेटर को वापस कर दे। सब कुछ सरल है:

 class ArrayObject implements IteratorAggregate { protected $array; public function __construct(array $array) { $this->array = $array; } public function getIterator() { foreach ($this->array as $key => $value) { yield $key => $value; } } } 

बात करने के लिए! अब हम जनरेटर के माध्यम से या सामान्य कुंजी एक्सेस सिंटैक्स के माध्यम से अपने सरणी के सभी गुणों पर पुनरावृति कर सकते हैं।

डेटा वापस भेजें

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

 function createLog($file) { $f = fopen($file, 'a'); while (true) { # ,   ; $line = yield; #  ""  send()     $line; fwrite($f, $line); } } $log = createLog($file); $log->send("First"); $log->send("Second"); $log->send("Third"); 

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

 function fetchBytesFromFile($file) { #   ,        $length = yield; #     $f = fopen($file, 'r'); while (!feof($f)) { #     $length = yield fread($f, $length); #    } yield false; } function processBytesInBatch(Generator $byteGenerator) { $buffer = ''; $bytesNeeded = 1000; while ($buffer .= $byteGenerator->send($bytesNeeded)) { #      // ,      list($lengthOfRecord) = unpack('N', $buffer); if (strlen($buffer) < $lengthOfRecord) { $bytesNeeded = $lengthOfRecord - strlen($buffer); continue; } yield substr($buffer, 1, $lengthOfRecord); $buffer = substr($buffer, 0, $lengthOfRecord + 1); $bytesNeeded = 1000 - strlen($buffer); } } $gen = processBytesInBatch(fetchBytesFromFile($file)); foreach ($gen as $record) { doSomethingWithRecord($record); } 

यह थोड़ा जटिल है, लेकिन मुझे आशा है कि आप समझते हैं कि यह कैसे काम करता है। हमने प्रसंस्करण और एक निश्चित आकार के डेटा को सही समय पर विभाजित किया + कोड का पुन: उपयोग करने की संभावना बनी हुई है।

और उदाहरण चाहिए!

सामान्य तौर पर, जनरेटर का उपयोग कई कार्यों में किया जा सकता है। उनमें से एक प्रवाह का अनुकरण है। सबसे पहले, हम प्रत्येक धागे को एक जनरेटर के रूप में परिभाषित करते हैं। फिर हम माता-पिता के लिए नियंत्रण संकेत बाहर फेंक देते हैं ताकि वह अगले धागे के लिए काम के लिए संकेत संचारित कर सके। हम ऐसी प्रणाली का निर्माण करेंगे जो विभिन्न डेटा स्रोतों के साथ काम करती है (हम गैर-अवरोधक इनपुट-आउटपुट के साथ काम करते हैं)। ऐसी प्रणाली का एक उदाहरण यहाँ दिया गया है:

 function step1() { $f = fopen("file.txt", 'r'); while ($line = fgets($f)) { processLine($line); yield true; } } function step2() { $f = fopen("file2.txt", 'r'); while ($line = fgets($f)) { processLine($line); yield true; } } function step3() { $f = fsockopen("www.example.com", 80); stream_set_blocking($f, false); $headers = "GET / HTTP/1.1\r\n"; $headers .= "Host: www.example.com\r\n"; $headers .= "Connection: Close\r\n\r\n"; fwrite($f, $headers); $body = ''; while (!feof($f)) { $body .= fread($f, 8192); yield true; } processBody($body); } // 3  (step)    -  true,    ,     function runner(array $steps) { while (true) { #   ,     foreach ($steps as $key => $step) { $step->next(); #        yield if (!$step->valid()) { # ,      ()  unset($steps[$key]); } } if (empty($steps)) return; #    -   } } runner(array(step1(), step2(), step3())); 

निष्कर्ष

जनरेटर बहुत शक्तिशाली सामान हैं। वे आपको कोड को बहुत सरल बनाने की अनुमति देते हैं। जरा सोचिए, आप एक पंक्ति में संख्याओं की एक संख्या के लिए एक फ़ंक्शन लिख सकते हैं:

 function xrange($min, $max) { for ($i = $min; $i < $max; $i++) yield $i; } 

छोटा और सरल। पढ़ने में आसान, समझने में आसान कि यह कैसे काम करता है, और बहुत ही उत्पादक - एक पुनरावृत्ति की तुलना में तेज़।

मूल लेख - एंथोनी फेरारा @ blog.ircmaxell.com

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

जनरेटर के बारे में संक्षेप में

- भाषा में नई कार्यक्षमता न जोड़ें
- तेज़ *
- जनरेटर की बहाली अंतिम "रिलीज" उपज से होती है
- आप जनरेटर और थ्रो (विधि) के माध्यम से मान और अपवाद भेज सकते हैं
- जनरेटर यूनिडायरेक्शनल हैं, अर्थात्। वापस नहीं जा सकते
- ज्यादातर मामलों में कम कोड, डिजाइन समझने में आसान

* इन परिणामों के आधार पर ।
एक बड़ी खोज के साथ, जनरेटर तेज होते हैं। पुनरावृत्तियों की तुलना में लगभग 4 गुना तेज और नियमित पुनरावृत्तियों की तुलना में 40% अधिक तेज है। तत्वों की एक छोटी संख्या के साथ, वे सामान्य पुनरावृत्ति की तुलना में धीमा हो सकते हैं, लेकिन फिर भी पुनरावृत्तियों की तुलना में अधिक तेज़ हैं।

यदि समुदाय अनुवाद को मंजूरी देता है और इसे अच्छा मानता है (और सबसे महत्वपूर्ण बात, बकवास को स्वीकार नहीं करता है और कोड का सार नहीं बदलता है), तो मेरे लिए कभी-कभी अन्य लेखों का अनुवाद करना दिलचस्प होगा।
मुझे लगता है कि डेटा संरचनाओं के बारे में phpmaster पर अब प्रकाशित लेखों के एक समूह को एक साथ अनुवाद करना और अनुवाद करना बेहतर नहीं होगा।
मुझे किसी भी टिप्पणी, निर्देश, टिप्पणियों के बारे में कोड के साथ पाठ में और अनुवाद में ही खुशी होगी।

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