स्विफ्ट यूनिवर्स में Iterator आर्किटेक्चरल पैटर्न

"इटरेटर" एक ऐसा डिज़ाइन पैटर्न है जिसे प्रोग्रामर अक्सर नोटिस नहीं करते हैं, क्योंकि इसका कार्यान्वयन, एक नियम के रूप में, सीधे प्रोग्रामिंग भाषा के मानक टूल में बनाया गया है। हालाँकि, यह "गंग ऑफ फोर", "GoF", "डिज़ाइन पैटर्न: पुन: प्रयोज्य वस्तु-उन्मुख सॉफ्टवेयर के तत्व" पुस्तक में वर्णित व्यवहार पैटर्न में से एक है, और समझे इसका उपकरण कभी दर्द नहीं करता है, और कभी-कभी यह किसी चीज़ में मदद भी कर सकता है।

एक "पुनरावृत्त" एक समग्र वस्तु के सभी तत्वों (विशेष रूप से, कंटेनर प्रकार, जैसे कि एक सरणी या सेट) के क्रमिक उपयोग की एक विधि है।

मानक भाषा उपकरण

किसी प्रकार की सरणी बनाएँ:

let numbersArray = [0, 1, 2] 

... और फिर एक चक्र में इसके माध्यम से "चलना":

 for number in numbersArray { print(number) } 

... एक बहुत स्वाभाविक कार्रवाई की तरह लगता है, विशेष रूप से स्विफ्ट जैसी आधुनिक प्रोग्रामिंग भाषाओं के लिए। हालांकि, इस सरल क्रिया के पर्दे के पीछे कोड है जो Iterator पैटर्न के सिद्धांतों को लागू करता है।

"स्विफ्ट" में, साइकिल के for एक चर को "पुनरावृति" करने में सक्षम होने के for , चर प्रकार को Sequence प्रोटोकॉल को लागू करना चाहिए। अन्य बातों के अलावा, इस प्रोटोकॉल के लिए एक associatedtype Iterator के प्रकार की आवश्यकता होती है, जो IteratorProtocol प्रोटोकॉल के साथ-साथ कारखाने विधि makeIterator() की आवश्यकताओं को लागू करना चाहिए, जो इस प्रकार के लिए एक विशिष्ट " makeIterator() " लौटाता है:

 protocol Sequence { associatedtype Iterator : IteratorProtocol func makeIterator() -> Self.Iterator // Another requirements go here… } 

IteratorProtocol प्रोटोकॉल, बदले में, केवल एक विधि शामिल है - next() , जो अनुक्रम में अगला तत्व देता है:

 protocol IteratorProtocol { associatedtype Element mutating func next() -> Self.Element? } 

ऐसा लगता है कि "बहुत जटिल कोड है," लेकिन वास्तव में यह नहीं है। नीचे हम इसे देखेंगे।

Array प्रकार Sequence प्रोटोकॉल को लागू करता है (हालांकि सीधे नहीं, लेकिन प्रोटोकॉल वंशानुक्रम श्रृंखला के माध्यम से: MutableCollection Collection आवश्यकताओं को विरासत में मिला है, और उत्तरार्द्ध Sequence आवश्यकताओं को विरासत में मिला है), इसलिए इसके उदाहरण, विशेष रूप से, चक्र के for "iterated" हो सकते हैं।

कस्टम प्रकार

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

मान लीजिए कि बुकशेल्फ़ का प्रतिनिधित्व करने वाला एक प्रकार है जो एक वर्ग के उदाहरणों का एक निश्चित सेट संग्रहीत करता है, जो बदले में एक पुस्तक का प्रतिनिधित्व करता है:

 struct Book { let author: String let title: String } struct Shelf { var books: [Book] } 

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

 struct ShelfIterator: IteratorProtocol { private var books: [Book] init(books: [Book]) { self.books = books } mutating func next() -> Book? { // TODO: Return next underlying Book element. } } extension Shelf: Sequence { func makeIterator() -> ShelfIterator { return ShelfIterator(books: books) } } 

ShelfIterator प्रकार की next() विधि को mutating घोषित किया ShelfIterator , क्योंकि इस प्रकार की आवृत्ति को वर्तमान स्थिति के अनुरूप किसी भी स्थिति में संग्रहित करना चाहिए:

 mutating func next() -> Book? { defer { if !books.isEmpty { books.removeFirst() } } return books.first } 

यह कार्यान्वयन विकल्प हमेशा अनुक्रम में पहला तत्व लौटाता है, या अनुक्रम खाली होने पर nil करता है। defer ब्लॉक defer पुनरावृत्त संग्रह को बदलने के लिए कोड के साथ "लपेटा" गया है, जो विधि रिटर्न के तुरंत बाद अंतिम चलना कदम के तत्व को हटा देता है।

उपयोग उदाहरण:

 let book1 = Book(author: ". ", title: "") let book2 = Book(author: ". ", title: " ") let book3 = Book(author: ". ", title: " ") let shelf = Shelf(books: [book1, book2, book3]) for book in shelf { print("\(book.author) – \(book.title)") } /* .  –  .  –   .  –   */ 

क्योंकि उपयोग किए जाने वाले सभी प्रकार ( Array अंतर्निहित Shelf सहित) मूल्यों के शब्दार्थ पर आधारित हैं (संदर्भों के विपरीत) , आपको पुनरावृत्ति के दौरान मूल चर के मूल्य के बारे में चिंता करने की ज़रूरत नहीं है। लिंक शब्दार्थ पर आधारित प्रकारों को संभालते समय, इस बिंदु को ध्यान में रखा जाना चाहिए और अपने स्वयं के पुनरावृत्तियों को बनाते समय ध्यान में रखा जाना चाहिए।

क्लासिक कार्यक्षमता

"गैंग्स ऑफ़ फोर" पुस्तक में वर्णित क्लासिक "इटेरेटर", पुनरावृत्ति अनुक्रम के अगले तत्व को वापस करने के अलावा, किसी भी समय पुनरावृत्ति प्रक्रिया में वर्तमान तत्व को वापस कर सकता है, पुनरावृत्त अनुक्रम का पहला तत्व और "ध्वज" का मूल्य इंगित करता है कि क्या अभी भी हैं मौजूदा पुनरावृत्ति कदम के सापेक्ष एक पुनरावृत्त अनुक्रम में तत्व।

बेशक, इस प्रकार मानक IteratorProtocol की क्षमताओं का विस्तार करते हुए एक प्रोटोकॉल घोषित करना आसान होगा:

 protocol ClassicIteratorProtocol: IteratorProtocol { var currentItem: Element? { get } var first: Element? { get } var isDone: Bool { get } } 

पहला और वर्तमान तत्व तब से वैकल्पिक रूप से वापस आ गए हैं स्रोत अनुक्रम खाली हो सकता है।

सरल कार्यान्वयन विकल्प:

 struct ShelfIterator: ClassicIteratorProtocol { var currentItem: Book? = nil var first: Book? var isDone: Bool = false private var books: [Book] init(books: [Book]) { self.books = books first = books.first currentItem = books.first } mutating func next() -> Book? { currentItem = books.first books.removeFirst() isDone = books.isEmpty return books.first } } 

पैटर्न के मूल विवरण में, next() विधि अगले तत्व पर जाने के लिए currentElement() की आंतरिक स्थिति को बदल देता है और प्रकार Void , और वर्तमान तत्व currentElement() विधि द्वारा वापस आ जाता है। IteratorProtocol प्रोटोकॉल में, ये दो कार्य इस प्रकार हैं जैसे कि एक में संयोजित किया गया हो।

first() विधि की आवश्यकता भी संदिग्ध है, क्योंकि पुनरावृति मूल अनुक्रम को परिवर्तित नहीं करता है, और हमारे पास हमेशा इसका पहला तत्व (यदि कोई हो,) का उपयोग करने का अवसर है।

और, चूंकि next() विधि nil जब पुनरावृत्ति समाप्त हो जाती है, तो isDone() विधि भी बेकार हो जाती है।

हालांकि, शैक्षणिक उद्देश्यों के लिए, एक ऐसे फ़ंक्शन के साथ आना संभव है जो पूर्ण कार्यक्षमता का उपयोग कर सकता है:

 func printShelf(with iterator: inout ShelfIterator) { var bookIndex = 0 while !iterator.isDone { bookIndex += 1 print("\(bookIndex). \(iterator.currentItem!.author) – \(iterator.currentItem!.title)") _ = iterator.next() } } var iterator = ShelfIterator(books: shelf.books) printShelf(with: &iterator) /* 1. .  –  2. .  –   3. .  –   */ 

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

next() विधि को कॉल करने के परिणाम का उपयोग नहीं किया जाता है, पाठ्यपुस्तक कार्यान्वयन के वापसी मूल्य की अनुपस्थिति का अनुकरण करता है।

एक निष्कर्ष के बजाय

यह सब मुझे लगता है कि मैं इस बार कहना चाहता था। सभी सुंदर कोड और जानबूझकर इसे लिखना!

डिजाइन पैटर्न पर मेरे अन्य लेख:

• "आईओएस" और "स्विफ्ट" के ब्रह्मांड में "आर्किटेक्चरल टेम्पलेट" विज़िटर "(" विज़िटर ")
• स्विफ्ट और आईओएस यूनिवर्स में फैक्ट्री मेथड और एब्सट्रैक्ट फैक्ट्री
• "स्विफ्ट" और "आईओएस" / "मैकओएस" के ब्रह्मांड में "वास्तुशिल्प पैटर्न" बिल्डर "