Iterators और जनरेटर

प्रसंस्करण संग्रह / सरणी तत्व एक सामान्य और लगातार संचालन है। जावास्क्रिप्ट के पास एक संग्रह को पार करने के कई तरीके हैं, for(;;) एक सरल और for a in b

 var divs = document.querySelectorAll('div'); for (var i = 0, c = divs.length; i < c; i++) { console.log(divs[i].innerHTML); } 

 var obj = {a: 1, b: 2, c: 3}; for (var i in obj) { console.log(i, obj[i]); } 

Array ऑब्जेक्ट में map(), filter() सभी तत्वों map(), filter() लिए ट्रैवर्सल विधियाँ हैं

 var numbers = [1, 2, 3, 4, 5]; var doubled = numbers.map(function (item) { return item * 2; }); console.log(doubled); 

फ़ायरफ़ॉक्स में ऐरे कॉम्प्रिहेंशन है

 var numbers = [1, 2, 3, 4]; var doubled = [i * 2 for each (i in numbers)]; console.log(doubled); // [2, 4, 6, 8] 

Iterators और Generators जावास्क्रिप्ट 1.7 में दिखाई दिए (मोज़िला के अनुसार) अब तक वे फ़ायरफ़ॉक्स 2+ में हैं (लेख में उल्लेख किया जाएगा कि कैसे वे एक बैसाखी के साथ लगभग सभी ब्राउज़रों में "अनुकरण" किए जा सकते हैं) Iterators और Generators एक तंत्र का परिचय देते हैं जिसे आप अपने नियंत्रण for in वस्तुओं की सूची में अगला तत्व प्राप्त करने की प्रक्रिया को इनकैप्सुलेट करें।

अक्सर, किसी ऐरे के तत्वों को इधर-उधर करने के लिए, हम बड़े निर्माण लिखते हैं, अक्सर उनके कुछ हिस्सों को कॉपी और पेस्ट करते हैं। जेनरेटर और इटरेटर्स का काम सिंटैक्टिक शुगर को जोड़कर इस प्रक्रिया को परिष्कृत करना है।

iterators

हर कोई जानता है कि जावास्क्रिप्ट में आप लगभग किसी भी वस्तु को बायपास कर सकते हैं:
सरणी

 var object = [1,2,3]; for (var i in object) { console.log(i, object[i]); } 

वस्तु

 var object = {a:1, b:2, c:3}; for (var i in object) { console.log(i, object[i]); } 

पंक्ति

 var object = 'abc'; for (var i in object) { console.log(i, object[i]); } 

किसी प्रकार की सूची

 var object = document.querySelectorAll('div'); for (var i in object) { if (object.hasOwnProperty(i)) { console.log(i, object[i]); } } 

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

एक इटरेटर एक ऐसी वस्तु है जो इस क्रम में अपनी वर्तमान स्थिति (कर्सर) को बनाए रखते हुए, संग्रह के तत्वों को एक समय में एक्सेस करना जानता है। जावास्क्रिप्ट में, एक इट्रेटर एक ऐसी वस्तु है जिसमें एक next() विधि होती है जो अगली वस्तु को एक अनुक्रम में लौटाती है। यह विधि अनुक्रम समाप्त होने पर StopIteration अपवाद को फेंक सकती है।

एक पुनरावृत्त को कई तरीकों से इस्तेमाल किया जा सकता है: सीधे next() विधि को कॉल करने के for...in या for...in या (केवल एफएफ) के निर्माण के लिए उपयोग करना।

पुनरावृति बनाने के कई तरीके हैं:

कॉल इटरेटर फंक्शन

 var lang = { name: 'JavaScript', birthYear: 1995 }; var it = Iterator(lang); // <<< 

इट्रेटर बनाने के बाद, it ऑब्जेक्ट next() का उपयोग करके पुनरावृत्त किया जा सकता है

 var pair = it.next(); //  ["name", "JavaScript"] pair = it.next(); //  ["birthYear", 1995] pair = it.next(); //    StopIteration 

वर्कअराउंड के लिए, आप for...in या for each उपयोग कर सकते हैं। जैसे ही StopIteration अपवाद StopIteration जाता है, तो बाईपास रोक दिया जाएगा:

 var it = Iterator(lang); for (var pair in it) { console.log(pair); // 2  [key, value] } 

Iterator() के फायदों में से एक यह है कि यह केवल अपने ही गुणों को querySelectorAll कर देता है (जब आप रेंगते हैं तो querySelectorAll क्रॉल का उदाहरण याद रखें) आपको object.hasOwnProperty जांच करने की आवश्यकता नहीं है object.hasOwnProperty ।

Iterator() उपयोग सरणी के लिए भी किया जा सकता है:

 var langs = ['JavaScript', 'Python', 'C++']; var it = Iterator(langs); for (var pair in it) { console.log(pair); // [index, language] } 

यदि दूसरा तर्क Iterator फ़ंक्शन को दिया जाता है, तो केवल अनुक्रमित को पुन: प्रसारित किया जाएगा:

 var langs = ['JavaScript', 'Python', 'C++']; var it = Iterator(langs, true); for (var pair in it) { console.log(pair); // 0, 1, 2 } 

इंडेक्स और वैल्यू के लिए, आप let और डिस्ट्रक्टिव असाइनमेंट (केवल एफएफ) का उपयोग करके अपने स्वयं के चर को उजागर कर सकते हैं:

 var langs = ['JavaScript', 'Python', 'C++']; var it = Iterator(langs); for (let [i, lang] in it) { //  FF console.log(i + ': ' + lang); //  "0: JavaScript" . } 

पुनरावृत्तियों को बनाने का यह तरीका बहुत उपयोगी नहीं है और Iterator बिना सामान्य रूप से समान है।

अपने चलने वाले बनाएँ

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

चलिए एक साधारण रेंज ऑब्जेक्ट बनाते हैं जो एक रेंज स्टोर करता है।

 function Range(low, high){ this.low = low; this.high = high; } 

अब अपना itter बनाएं जो इस श्रेणी से एक अनुक्रम लौटाता है। इटरेटर इंटरफ़ेस हमें एक next() विधि बनाने की आवश्यकता है जो एक अनुक्रम तत्व को लौटाएगा और अंत में एक StopIteration अपवाद फेंक देगा।

 function RangeIterator(range){ this.range = range; this.current = this.range.low; } RangeIterator.prototype.next = function(){ if (this.current > this.range.high) throw StopIteration; else return this.current++; }; 

 var ri = new RangeIterator(new Range(1, 10)); ri.next(); // ... ri.next(); // StopIteration 

किसी तरह बहुत सुविधाजनक नहीं है। RangeIterator कंस्ट्रक्टर से छुटकारा पाने के लिए, RangeIterator Range ऑब्जेक्ट __iterator__ विधि का उपयोग करेंगे। किसी Range ऑब्जेक्ट के तत्वों पर पुनरावृति करने का प्रयास करते समय इस विधि को कहा जाएगा। इस विधि में एक RangeIterator जाना चाहिए जिसमें RangeIterator तर्क शामिल है।

 Range.prototype.__iterator__ = function(){ return new RangeIterator(this); }; var range = new Range(3, 5); for (var i in range) { console.log(i); // 3, 4, 5 } 

आरामदायक पर्याप्त है, लेकिन बहुत अधिक अनावश्यक है।

जनरेटर

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

एक जनरेटर एक विशेष प्रकार का फ़ंक्शन है जो पुनरावृत्तियों को बनाने के लिए एक कारखाने की तरह काम करता है। कोई भी फ़ंक्शन जिसमें कम से कम एक yield है, एक जनरेटर बन जाता है।

नोट: मूल में, जनरेटर केवल फ़ायरफ़ॉक्स 2+ में जावास्क्रिप्ट के ओवरराइड संस्करण के साथ उपलब्ध हैं <script type="application/javascript;version=1.7">

जब एक जनरेटर फ़ंक्शन कहा जाता है, तो इसका शरीर निष्पादित नहीं होता है। यह एक कंस्ट्रक्टर के रूप में काम करता है जो एक इटरेटर-जेनरेटर बनाता है और वापस करता है। next() Iterator-Generator विधि का प्रत्येक कॉल फ़ंक्शन के शरीर को निष्पादित करेगा जब तक कि yield वापस नहीं होती है, जो परिणाम देता है। यदि फ़ंक्शन return साथ समाप्त हो जाता है या फ़ंक्शन का शरीर समाप्त हो जाता है, तो एक StopIteration अपवाद फेंक दिया जाएगा और इट्रेटर काम करना बंद कर देगा।

आइए एक उदाहरण में वर्णन करें:

 function simpleGenerator(){ yield "first"; yield "second"; yield "third"; for (var i = 0; i < 3; i++) { yield i; } } var g = simpleGenerator(); console.log(g.next()); // "first" console.log(g.next()); // "second" console.log(g.next()); // "third" console.log(g.next()); // 0 console.log(g.next()); // 1 console.log(g.next()); // 2 console.log(g.next()); // StopIteration 

जेनरेटर फंक्शन का इस्तेमाल __iterator__ ऑब्जेक्ट के तरीके के रूप में किया जा सकता है। यह कोड की मात्रा को काफी कम कर देगा। हम जनरेटर का उपयोग करके रेंज के साथ उदाहरण को फिर से लिखते हैं:

 function Range(low, high){ this.low = low; this.high = high; } Range.prototype.__iterator__ = function(){ for (var i = this.low; i <= this.high; i++) { yield i; } }; var range = new Range(3, 5); for (var i in range) { console.log(i); // 3, 4, 5 } 

यह 3 गुना कम निकला

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

 function fibonacci(){ var fn1 = 1; var fn2 = 1; while (1){ var current = fn2; fn2 = fn1; fn1 = fn1 + current; yield current; } } var sequence = fibonacci(); console.log(sequence.next()); // 1 console.log(sequence.next()); // 1 console.log(sequence.next()); // 2 console.log(sequence.next()); // 3 console.log(sequence.next()); // 5 console.log(sequence.next()); // 8 // ... 

जेनरेटर के कार्यों को तर्क दिया जा सकता है। आप StopIteration या return का उपयोग कर जनरेटर को बाधित कर सकते return । हम limit तर्क का उपयोग करके फाइबोनैचि संख्याओं के साथ उदाहरण को फिर से लिखते हैं।

 function fibonacci(limit){ var fn1 = 1; var fn2 = 1; while (1) { var current = fn2; fn2 = fn1; fn1 = fn1 + current; if (limit && current > limit) { return; } yield current; } } var sequence = fibonacci(7); console.log(sequence.next()); // 1 console.log(sequence.next()); // 1 console.log(sequence.next()); // 2 console.log(sequence.next()); // 3 console.log(sequence.next()); // 5 console.log(sequence.next()); // StopIteration 

उन्नत जेनरेटर

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

next() विधि के अलावा, जेनरेटर-इटरेटर में एक send() विधि है जो आपको जनरेटर की आंतरिक स्थिति को बदलने की अनुमति देती है। send() लिए पारित मूल्य send() जनरेटर को रोकने वाली अंतिम yield के परिणाम के रूप में व्याख्या की जाएगी। आपको कॉल send() से पहले next() साथ जनरेटर शुरू करना होगा।

यहाँ एक पुन: लिखित फिबोनाची जनरेटर है जो किसी अनुक्रम को पुनः आरंभ करने के लिए send() का उपयोग करता है:

 function fibonacci(){ var fn1 = 1; var fn2 = 1; while (1){ var current = fn2; fn2 = fn1; fn1 = fn1 + current; var reset = yield current; if (reset){ fn1 = 1; fn2 = 1; } } } var sequence = fibonacci(); print(sequence.next()); // 1 print(sequence.next()); // 1 print(sequence.next()); // 2 print(sequence.next()); // 3 print(sequence.next()); // 5 print(sequence.send(true)); // 1 print(sequence.next()); // 1 print(sequence.next()); // 2 print(sequence.next()); // 3 

आप throw() विधि को कॉल करके अपवादों को फेंकने के लिए मजबूर कर सकते हैं। यह विधि एक तर्क लेती है, जो जनरेटर को फेंक देगा ( throw value; )। यह अपवाद जनरेटर के वर्तमान रुके हुए संदर्भ (उस स्थान पर जहां अंतिम yield ) से फेंक दिया जाएगा।

यदि जनरेटर शुरू नहीं किया गया था next() विधि के लिए कोई कॉल नहीं था, तो throw() next() कॉल करेगा next() और yield स्थान पर एक अपवाद फेंक देगा।

आप जनरेटर को close() विधि का उपयोग कर बंद कर सकते हैं:
यह विधि निम्न कार्य करती है:
- सभी finally ब्लॉक निष्पादित किया जाएगा
- यदि finally StopIteration अलावा कोई अन्य अपवाद ब्लॉक करता है, तो उस अपवाद को उस संदर्भ में फेंक दिया जाएगा जहां से close() विधि को बुलाया गया था
- जनरेटर नष्ट हो गया है

अभिव्यक्ति जनरेटर

"ऐरे प्लेसहोल्डर" में एक महत्वपूर्ण खामी है जब इसे बुलाया जाता है, यह सरणी को भरता है और मेमोरी को ऊपर ले जाता है। जब सरणी छोटा है, तो यह असंगत है, बड़े सरणियों के मामले में यह बहुत महंगा है, और तत्वों की एक अनंत संख्या के मामले में, "एरे प्लेसहोल्डर" का कोई मतलब नहीं है।

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

मान लीजिए कि हमारे पास एक इट्रेटर है जो बड़ी संख्या में पूर्णांकों का पता लगाता है। हम एक नया पुनरावृत्त बनाना चाहते हैं जो डुप्लिकेट संख्याओं पर पुनरावृति करेगा। "एरे प्लेसहोल्डर" का उपयोग करके हम मेमोरी में एक पूरे सरणी को गुणा मानों को बनाएंगे:

 var doubles = [i * 2 for (i in it)]; 

अभिव्यक्ति जनरेटर एक नया पुनरावृत्ति पैदा करेगा जो मांग पर संख्याओं को गुणा करेगा:

 var it2 = (i * 2 for (i in it)); print(it2.next()); //    print(it2.next()); //    

एक फ़ंक्शन के लिए एक तर्क के रूप में एक अभिव्यक्ति जनरेटर पारित किया जा सकता है। इस मामले में अतिरिक्त कोष्ठक छोड़े जा सकते हैं:

 var result = doSomething(i * 2 for (i in it)); 

उदाहरण

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

1. डोम ट्री ट्रैवर्सल

पृष्ठ पर कई लिंक हैं। प्रत्येक के लिए, आपको डोमेन और innerHTML प्राप्त करने की आवश्यकता होती है innerHTML और यदि innerHTML डोमेन से मेल खाता है, तो डोमेन को कंसोल में प्रदर्शित करें।

टेस्ट लिंक:

 <a href="http://ya.ru/"> </a> <a href="http://google.ru/"></a> <a href="http://habrahabr.ru/"></a> <a href="http://twitter.com/">twitter.com</a> 

जनरेटर के लिए हमारा कोड:

 var aList = document.querySelectorAll('a'); for (var i = 0, c = aList.length, a, content, domain; i < c; i++) { a = aList[i]; content = a.innerHTML; domain = a.getAttribute('href').replace('http://', '').split('/').shift(); if (content === domain) { console.log(domain); } } 

सब कुछ प्राकृतिक और स्पष्ट है। और अगर हमें अन्य जांच के लिए इस चक्र का उपयोग करने की आवश्यकता है? कोड कॉपी करें? जेनरेटर मदद करता है;) पुनर्लेखन:

  //    type="application/javascript;version=1.7" var aDomainContentGenerator = function () { var aList = document.querySelectorAll('a'); for (var i = 0, c = aList.length, a, content, domain; i < c; i++) { a = aList[i]; content = a.innerHTML; domain = a.getAttribute('href').replace('http://', '').split('/').shift(); yield {domain: domain, content: content}; } }; var ancors = aDomainContentGenerator(); //  -      //   for c if,   . ,     var ancorsWithSameContentAndDomain = (item for (item in ancors) if (item.content === item.domain)); for (item in ancorsWithSameContentAndDomain) { console.log(item.domain); } 

कोड थोड़ा अधिक निकला, लेकिन कोड चौड़ाई में बढ़ गया है (यह एक महत्वपूर्ण प्लस है) और अब हम अन्य उद्देश्यों के लिए aDomainContentGenerator() जनरेटर का उपयोग कर सकते हैं।

2. पेड़ की टहनी

एक पेड़ है जिसमें पंक्तियाँ बिखरी पड़ी हैं। उन्हें आरोही क्रम में प्रदर्शित करना आवश्यक है:

 function Tree(left, label, right) { this.left = left; this.label = label; this.right = right; } //      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; } } } //    function make(array) { //  : if (array.length == 1) return new Tree(null, array[0], null); return new Tree(make(array[0]), array[1], make(array[2])); } var tree = make([[['a'], 'b', ['c']], 'd', [['e'], 'f', ['g']]]); //  for (var node in inorder(tree)) { console.log(node); // a, b, c, d, ... } 

कोड में एक भारी संरचना थी

 for (var item in inorder(t.right)) { yield item; } 

भविष्य में वे किसके साथ बदलना चाहते हैं:

 yield for inorder(t.right); 

जनरेटर के लिए इस्तेमाल किया जा सकता है

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

जेनरेटर के लाभ

1. ऑन-डिमांड गणना करें
2. अतिरिक्त मेमोरी न लें
3. एक संग्रह आइटम प्राप्त करने की प्रक्रिया को इनकैप्सुलेट करें
4. कोड को स्ट्रेच करें
5. जनरेटर का उपयोग पाइप लाइन में ग्लूइंग द्वारा फिल्टर के रूप में किया जा सकता है

उत्पादकता

पायथन परीक्षणों के अनुसार, जेनरेटर साधारण चक्रों से कमतर नहीं हैं। प्रस्तुति में और पढ़ें " जेनरेटर ट्रिक्स सिस्टम प्रोग्रामर्स के लिए एक परिचय " (स्लाइड 22)
जेनरेटर बनाम कॉमन लूप परीक्षण के अनुसार, जनरेटर चक्र की तुलना में एक तिहाई धीमा हैं।

इसका उपयोग कब किया जा सकता है?

ओवरराइड के साथ फ़ायरफ़ॉक्स 2 में, जावास्क्रिप्ट संस्करण अभी लिखे जा सकते हैं। बाकी सब खराब हो रहा है। एक अच्छी परियोजना है - Google ट्रेसुर-कंपाइलर। यह संकलक आपको ES6 + के भविष्य के संस्करणों के कोड को ES3 कोड में संसाधित करने की अनुमति देता है। लेकिन यह रामबाण नहीं है, उदाहरण के लिए "ट्री वॉकिंग" का कोड किसी भी ब्राउज़र में काम नहीं करता है
टीसी जनरेटर के लिए समझ में नहीं आता है।

 for (var node in inorder(tree)) { console.log(node); // a, b, c, d, ... } 

उसकी जरूरत है

 for (let node : inorder(tree)) { console.log(node); // a, b, c, d, ... } 

लेकिन यह दृश्य फ़ायरफ़ॉक्स को नहीं समझता है। टीसी को Function#bind , Object.defineProperty आवश्यकता होती है इसलिए संकलित संस्करण केवल टीसी क्रिएटर के ब्राउज़र - क्रोम क्रोम :) में काम करता है। संकलित जनरेटर कोड एक परिमित राज्य मशीन का उपयोग करके राक्षसी है और try catch और अन्य आवृत्तियों के आसपास नृत्य कर रहा है। यह इस तरह के एक "कोड" निकलता है:

 function Tree(left, label, right) { this.left = left; this.label = label; this.right = right; } function inorder(t) { var $that = this; return { __traceurIterator__: function() { var $state = 20; var $storedException; var $finallyFallThrough; var $__1; var $__2; var $__3; var $__4; var $result = { moveNext:(function() { while(true) try { switch($state) { case 20: if(t) { $state = 7; break; } else { $state = 15; break; } case 7: $__2 = inorder(t.left).__traceurIterator__(); $state = 8; break; case 8: if($__2.moveNext()) { $state = 2; break; } else { $state = 5; $finallyFallThrough = 4; break; } case 2: $__1 = $__2.current; $state = 3; break; case 3: $result.current = $__1; $state = 8; return true; case 5: { if($__2.close) $__2.close(); } $state = 6; break; case 4: $result.current = t.label; $state = 10; return true; case 10: $__4 = inorder(t.right).__traceurIterator__(); $state = 19; break; case 19: if($__4.moveNext()) { $state = 13; break; } else { $state = 16; $finallyFallThrough = 15; break; } case 13: $__3 = $__4.current; $state = 14; break; case 14: $result.current = $__3; $state = 19; return true; case 16: { if($__4.close) $__4.close(); } $state = 17; break; case 6: $state = $finallyFallThrough; break; case 17: $state = $finallyFallThrough; break; case 15: $state = 22; case 22: return false; case 21: throw $storedException; default: throw "traceur compiler bug: invalid state in state machine" + $state; } } catch($caughtException) { $storedException = $caughtException; switch($state) { case 8: $state = 5; $finallyFallThrough = 21; break; case 2: $state = 5; $finallyFallThrough = 21; break; case 3: $state = 5; $finallyFallThrough = 21; break; case 19: $state = 16; $finallyFallThrough = 21; break; case 13: $state = 16; $finallyFallThrough = 21; break; case 14: $state = 16; $finallyFallThrough = 21; break; default: throw $storedException; } } }).bind($that) }; return $result; } }; } function make(array) { if(array.length == 1) return new Tree(null, array[0], null); return new Tree(make(array[0]), array[1], make(array[2])); } var tree = make([[['a'], 'b',['c']], 'd',[['e'], 'f',['g']]]); { var $__0 = inorder(tree).__traceurIterator__(); try { while($__0.moveNext()) { try { throw undefined; } catch(node) { node = $__0.current; { console.log(node); } } } } finally { if($__0.close) $__0.close(); } } 

आधे लेख के लिए कोड - यह दिखाने के लिए छोड़ दिया कि उसके साथ सब कुछ बुरा है ...

निष्कर्ष

मूल में, जेनरेटर का उपयोग केवल फ़ायरफ़ॉक्स में किया जा सकता है, जिसका अर्थ है कि आप इसका उपयोग नहीं कर सकते (लेकिन आप खेल सकते हैं)। यहां तक ​​कि अगर हम Function#bind समाप्त करते हैं Function#bind और Object.defineProperty , किसी भी मामले में टीसी कोड को एक दैत्य राक्षस में बदल देता है और इसलिए इसका उपयोग संदिग्ध है।

एकमात्र जगह जहां उन्हें सफलतापूर्वक लागू किया जा सकता है वह भविष्य का स्पाइडरनोड है । Iterators और जेनरेटर अविश्वसनीय रूप से उपयोगी सामान हैं। क्लाइंट पर हम उन्हें 5 साल (सभी ज्ञात कारणों के लिए) में उपयोग करेंगे। सर्वर पर, जल्द ही उम्मीद है।

आदर

1. एमडीसी - एरियर की समझ
2. ईएस हार्मनी इटरेटर
3. ईएस हार्मनी जेनरेटर
4. एमडीसी - एमडीसी Iterators और जेनरेटर गाइड
5. MDC - जावास्क्रिप्ट 1.7 में नया
6. ट्रेसुर-कंपाइलर LanguageFeatures

जावास्क्रिप्ट ने पायथन से 1-इन -1 जनरेटर और पुनरावृत्तियों को संभाला है, लेकिन अभी तक कुछ जावास्क्रिप्ट उदाहरण हैं। मैं पायथन संसाधनों के लिंक फेंक दूंगा:
7. पीईपी 380, " उप-जनरेटर को सौंपने के लिए सिंटैक्स "
8. पीईपी 255, " सरल जनरेटर "
9. प्रस्तुति " जेनरेटर ट्रिक्स सिस्टम प्रोग्रामर्स के लिए एक परिचय "

सुझाव, इच्छा, आलोचना का स्वागत है!

UPD जोड़ा जेनरेटर बनाम आम लूप जनरेटर प्रदर्शन परीक्षण