🤣 🏳️‍🌈 🐝 फंक्शन आधारित इटरेटर और जेनरेटर 👩‍👧‍👧 🚴🏻 🔣

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

अपने विषय में, मैं अक्सर "असली पुनरावृत्तियों" का उल्लेख करूंगा, जिसके द्वारा मेरा अर्थ है कि 1.7 जावास्क्रिप्ट से बहुत ही पुनरावृत्तियों कि aterproduction Iterators और जनरेटरों विषय में पूरी तरह से प्रकाशित।
मैं अत्यधिक अनुशंसा करता हूं कि आप अपने विषय के साथ खुद को परिचित करें, क्योंकि तुलना के लिए मैं उनके "वास्तविक" उदाहरणों के कोड का उपयोग करूंगा।

तो चलिए!

सरल उदाहरण है

वस्तुओं का एक निश्चित सेट है, चलो उन्हें यूनिट कहते हैं। आपको चक्रीय क्रम में सेट [लाल, हरा, नीला] से सभी इकाइयों को रंग देने की आवश्यकता है। अर्थात्, पहली इकाई लाल है, दूसरी हरी है, तीसरी नीली है, चौथी फिर से लाल है, और इसी तरह।

यह एक सहायक वस्तु के साथ पूरा होता है, जिसे मैं आमतौर पर रिवॉल्वर कहता हूं।

var colors = new Revolver(['red', 'green', 'blue']); for (var i = 0; i < units.length; i += 1) { units[i].color = colors.next(); }

रिवाल्वर निम्नानुसार है:

 function Revolver(items) { this.items = items; this.max = items.length - 1; this.i = -1; } Revolver.prototype.next = function () { this.i = this.i < this.max ? this.i + 1 : 0; return this.items[this.i]; };

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

एक सहायक वर्ग घोषित करें
इस वर्ग में अगली () विधि को परिभाषित करें,
मूल्यों के वांछित समूह के साथ कक्षा का एक उदाहरण बनाएं,
सेट से अगला मान प्राप्त करने के लिए उदाहरण की अगली () विधि को कॉल करें।

क्या रिवॉल्वर को सरल बनाना संभव है ताकि कोड छोटा हो जाए, और अर्थ अधिक हो?
आप कर सकते हैं! ~~कार्यों का उपयोग करें, ल्यूक!~~

 function revolver(items) { var max = items.length - 1, i = -1; return function () { i = i < max ? i + 1 : 0; return items[i]; }; } var next_color = revolver(['red', 'green', 'blue']); for (var i = 0; i < units.length; i += 1) { units[i].color = next_color(); }

अब एक विधि के साथ कोई वर्ग नहीं है, इसके बजाय, एक फ़ंक्शन है जो एक फ़ंक्शन देता है।
अर्थ की एकाग्रता अधिकतम है, क्योंकि वास्तव में हमें ऑब्जेक्ट के रूप में रंगों के एक सेट की आवश्यकता नहीं है, लेकिन एक सेट से अगले रंग प्राप्त करने की एक विधि है ।

एक संग्रह की अनुपस्थिति में संग्रह तत्व प्राप्त करने की विधि इस तरह से होती है जिसे इटरेटर कहा जाता है।

सिद्धांत

एक पुनरावृत्ति एक वस्तु है जो एक प्रोग्रामर को अपने कार्यान्वयन (विकिपीडिया) की विशेषताओं को ध्यान में रखे बिना किसी संग्रह के सभी तत्वों पर पुनरावृति करने की अनुमति देता है।

दिए गए उदाहरण में, संग्रह आर, जी, बी, आर, जी, बी, ..., और रंगों की एक अंतहीन दोहराई जाने वाली सेट है और संग्रह की विशेषताएं वास्तव में छिपी हुई हैं।

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

उदाहरण में, रिवॉल्वर फ़ंक्शन तत्वों के संचरित सेट से अनंत अनुक्रम पुनरावृत्तियों का एक जनरेटर है।

इस प्रकार, कार्यात्मक पुनरावृत्तियों और जनरेटर को निम्नानुसार परिभाषित किया जा सकता है:

एक पुनरावृत्ति एक फ़ंक्शन है जो क्रमिक कॉल में, संग्रह के तत्वों को लौटाता है;
एक जनरेटर एक फ़ंक्शन है जो एक पुनरावृत्ति फ़ंक्शन देता है।

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

 function fibonacci() { var fn1 = 1, fn2 = 1; return function () { var current = fn1; fn1 = fn2; fn2 = fn2 + current; return current; }; } var sequence = fibonacci(); for (var i = 0; i < 5; i += 1) { console.log(sequence()); // 1, 1, 2, 3, 5 }

यह काम करता है! इस जनरेटर के कोड के साथ तुलना करें:

 function fibonacci(){ var fn1 = 1, fn2 = 1; while (1) { var current = fn1; fn1 = fn2; fn2 = fn2 + current; yield current; } }

ऐसा लगता है, है ना?

अभ्यास

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

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

जाहिर है, कार्यात्मक चलने वाले काम करने का तरीका अलग होना चाहिए।

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

दूसरा वह निर्माण है जिसके द्वारा एक कार्यात्मक पुनरावृत्त को पुनरावृत्त किया जा सकता है। डिजाइन को न केवल इट्रेटर के लिए, बल्कि जनरेटर के लिए भी आवश्यक है। यहाँ सब कुछ भी काफी सरल है:

 //  — while var item; while (item = iterator()) { //  item } //  — for for (var item, iter = generator(); item = iter();) { //  item }

एक चक्र के आयोजन का एक उदाहरण: दो की शक्तियों का एक जनरेटर संख्या एन से अधिक नहीं।

 function powers_of_two(N) { var value = 1; return function () { var result = value; value *= 2; if (result < N) { return result; } }; } for (var p, iter = powers_of_two(42); p = iter();) { console.log(p); // 1, 2, 4, 8, 16, 32 }

मरहम में उड़ो, जहां इसके बिना

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

एक अच्छा उदाहरण Iterators और जनरेटर्स विषय से एक पेड़ ट्रैवर्सल जनरेटर है:

 function inorder(t) { if (t) { for (var item in inorder(t.left)) { yield item; } yield t.label; for (var item in inorder(t.right)) { yield item; } } }

यह स्पष्ट और तार्किक लगता है - हम बाईं शाखा के तत्वों को वापस करते हैं, फिर जड़, फिर दाईं शाखा के तत्वों को। क्लास।

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

आइए एक कार्यात्मक पुनरावर्ती पेड़ ट्रैवर्सल जनरेटर बनाने का प्रयास करें।
1, एक वास्तविक जनरेटर के तर्क का दोहराव:

 function inorder(t) { var root = false, left, right; if (t) { left = inorder1(t.left); right = inorder1(t.right); return function () { var item; if (item = left()) { return item; } if (!root) { root = true; return t.label; } if (item = right()) { return item; } }; } else { return function () {}; } }

यह ऐसा हुआ, लेकिन दो चीजें विशेष रूप से दुखद हैं।

1. पुनरावृत्त के शरीर में तीन वापसी बयानों की उपस्थिति। उपज कथन के मामले में, सब कुछ तर्कसंगत दिखता है, क्योंकि निष्पादन अगली पंक्ति से जारी है। हालांकि, अगर रिटर्न का उपयोग उपज के रूप में किया जाता है, तो तर्क टूट जाता है, और यह समझना अधिक कठिन हो जाता है कि क्या हो रहा है।

2. जनरेटर के इनपुट पर एक खाली पेड़ एक अलग खाली इट्रेटर रिटर्न फ़ंक्शन () {} द्वारा संसाधित किया जाता है, जो आगे कोड को भ्रमित करता है।

इस मामले में समस्याओं का स्रोत एक वास्तविक जनरेटर के तर्क की नकल कर रहा है जो जानता है कि इसकी स्थिति को कैसे बनाए रखा जाए। कार्यात्मक जनरेटर के कोड को समझने योग्य बनाने के लिए, आपको राज्य को अधिक स्पष्ट रूप से सहेजने की आवश्यकता है।

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

आइए कोड में लागू करने का प्रयास करें:

 function inorder(t) { var roots = [t], //     iters = []; if (t) { iters.push(inorder(t.left)); iters.push(function () {return roots[0] && roots.shift().label}); //   iters.push(inorder(t.right)); } return function () { var leaf; while (iters.length) { leaf = iters[0](); if (leaf) { return leaf; } iters.shift(); } }; }

यह लगभग अच्छी तरह से निकला - इट्रेटर में रिटर्न स्टेटमेंट एक है, और इटरेटर का कोड बहुत सरल है।

इस प्रकार, जटिल तर्क वाले कार्यात्मक जनरेटर काफी संभव हैं, लेकिन उनके निर्माण के लिए वास्तविक जनरेटर की तुलना में अधिक सावधानीपूर्वक विचार की आवश्यकता होती है।

Iterator प्रबंधन

विशेष रूप से सावधानीपूर्वक लोग विषय की शुरुआत में मेरे लिए आपत्ति कर सकते हैं, उदाहरण के लिए, इस तरह से: "एक मिनट रुको, आप कहते हैं कि एक इटेटर एक फ़ंक्शन है। "महान, लेकिन अगर आप पुनरावृत्त राज्य को रीसेट करने की आवश्यकता है, तो आप इस फ़ंक्शन के साथ क्या करेंगे?"

जवाब है: मैं इस फ़ंक्शन में एक विधि जोड़ूंगा :) जावास्क्रिप्ट में कार्य ऑब्जेक्ट हैं। बेशक, कार्यों के तरीके हो सकते हैं।

अच्छा पुराना फाइबोनैचि अनुक्रम, अब एक रीसेट विधि के साथ:

 function fibonacci_restartable() { var fn1 = 1, fn2 = 1, iterator; iterator = function () { var current = fn1; fn1 = fn2; fn2 = fn2 + current; return current; }; iterator.restart = function () { fn1 = fn2 = 1; }; return iterator; } var sequence = fibonacci_restartable(); for (var i = 0; i < 5; i += 1) { console.log(sequence()); // 1, 1, 2, 3, 5 } sequence.restart(); for (var i = 0; i < 5; i += 1) { console.log(sequence()); // 1, 1, 2, 3, 5 }

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

निष्कर्ष

डिजाइन पैटर्न के रूप में Iterators और जनरेटर अपने कार्यों के लचीलेपन के कारण जावास्क्रिप्ट में बहुत अच्छी तरह से जड़ लेते हैं। बेशक, कार्यात्मक पुनरावृत्तियों वास्तविक पुनरावृत्तियों के प्रदर्शन में नीच हैं, लेकिन उन स्थानों पर जहां प्रदर्शन महत्वपूर्ण नहीं है, कार्यात्मक पुनरावृत्तियों का उपयोग कोड को सरल और सरल बना सकता है।

आपका ध्यान के लिए धन्यवाद!