शुरुआती लोगों के लिए स्विफ्ट में कार्यात्मक प्रोग्रामिंग का थोड़ा अभ्यास

मैं सबसे सरल तरीके से शुरुआती लोगों को कार्यात्मक प्रोग्रामिंग की अवधारणा को पेश करना चाहता हूं, इसके कई अन्य लोगों से कुछ फायदे पर प्रकाश डाला गया है जो वास्तव में कोड को अधिक पठनीय और अभिव्यंजक बना देगा। मैंने आपके लिए कुछ दिलचस्प डेमो निकाले जो गितूब पर Playground पर हैं।

कार्यात्मक प्रोग्रामिंग: परिभाषा

सबसे पहले, कार्यात्मक प्रोग्रामिंग एक भाषा या वाक्यविन्यास नहीं है, लेकिन जटिल प्रक्रियाओं को सरल लोगों और उनकी बाद की रचना में तोड़कर समस्याओं को हल करने का एक तरीका है। जैसा कि नाम का अर्थ है, " कार्यात्मक प्रोग्रामिंग, " इस दृष्टिकोण के लिए रचना की इकाई एक फ़ंक्शन है ; और इस तरह के एक समारोह का उद्देश्य बदलते राज्य या इसके scope) बाहर मूल्यों से बचने के लिए scope) ।

Swift वर्ल्ड में, इसके लिए सभी स्थितियां हैं, क्योंकि यहां फ़ंक्शन प्रोग्रामिंग प्रक्रिया में ऑब्जेक्ट्स के समान पूर्ण प्रतिभागी हैं, और mutation की समस्या को value TYPES की अवधारणा के स्तर पर हल किया जाता है (संरचनात्मक संरचनाएं और enum एन्यूमरेशन जो म्यूटेबिलिटी ( mutation को प्रबंधित करने में मदद करते हैं। ) और स्पष्ट रूप से संवाद करें कि यह कैसे और कब हो सकता है।

हालाँकि, Swift पूर्ण अर्थों में, कार्यात्मक प्रोग्रामिंग की भाषा नहीं है, यह आपको कार्यात्मक प्रोग्रामिंग के लिए मजबूर नहीं करता है, हालांकि यह कार्यात्मक दृष्टिकोण के फायदे को पहचानता है और उन्हें एम्बेड करने के तरीके ढूंढता है।

इस लेख में, हम Swift में कार्यात्मक प्रोग्रामिंग के अंतर्निहित तत्वों का उपयोग करने पर ध्यान केंद्रित करेंगे (अर्थात, "बॉक्स से बाहर") और यह समझकर कि आप अपने आवेदन में कैसे आराम से उनका उपयोग कर सकते हैं।

इम्पीरेटिव एंड फंक्शनल अप्रूव्स: तुलना

कार्यात्मक दृष्टिकोण का मूल्यांकन करने के लिए, आइए कुछ सरल समस्या के समाधानों की दो अलग-अलग तरीकों से तुलना करें। पहला समाधान " इंपीरियल " है, जिसमें कोड प्रोग्राम के अंदर स्थिति को बदलता है।

 //Imperative Approach var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] for i in 0..<numbers.count { let timesTen = numbers[i] * 10 numbers[i] = timesTen } print(numbers) //[10, 20, 30, 40, 50, 60, 70, 80, 90, 100] 

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

1. आप अपने कोड के साथ क्या हासिल करने की कोशिश कर रहे हैं?
2. यदि आपका कोड चल रहा है तो एक और thread numbers सरणी तक पहुंचने का प्रयास करता है तो क्या होता है?
3. यदि आप numbers सरणी में मूल मानों तक पहुँच चाहते हैं, तो क्या होता है?
4. यह कोड कैसे विश्वसनीय हो सकता है?

अब एक वैकल्पिक " कार्यात्मक " दृष्टिकोण पर नजर डालते हैं:

 //Functional Approach let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] extension Array where Element == Int { func timesTen() -> [Int] { var output = [Int]() for num in self { output.append(num * 10) } return output } } let result = numbers.timesTen() print(numbers) //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(result) //[10, 20, 30, 40, 50, 60, 70, 80, 90, 100] 

कोड के इस टुकड़े में, हम कंसोल पर एक ही परिणाम प्राप्त करते हैं, समस्या का समाधान पूरी तरह से अलग तरीके से करते हैं। ध्यान दें कि इस बार हमारे numbers ऐरे, let कीवर्ड के लिए अपरिवर्तनीय हैं। हमने numbers सरणी से संख्याओं को गुणा करने की प्रक्रिया को timesTen() विधि में स्थानांतरित कर दिया है, जो कि Array के एक्सटेंशन extension में स्थित है। हम अभी भी लूप के for उपयोग करते हैं और output नामक एक चर को संशोधित करते हैं, लेकिन इस चर का दायरा केवल इस विधि द्वारा सीमित है। इसी प्रकार, हमारा इनपुट तर्क self timesTen() वैल्यू बाय वैल्यू ( by value ) में उत्तीर्ण होता है, आउटपुट वेरिएबल के समान स्कोप output । timesTen() विधि को कहा जाता है, और हम कंसोल पर मूल numbers सरणी और परिणाम सरणी result दोनों पर प्रिंट कर सकते हैं।
आइए अपने 4 प्रश्नों पर वापस जाएं।

1. आप अपने कोड के साथ क्या हासिल करने की कोशिश कर रहे हैं?

हमारे उदाहरण में, हम numbers सरणी में numbers को 10 से गुणा करके एक बहुत ही सरल कार्य करते हैं।

एक अनिवार्य दृष्टिकोण के साथ, आउटपुट प्राप्त करने के लिए, आपको लूप के निर्देशों का पालन करते हुए, कंप्यूटर की तरह सोचना होगा। इस स्थिति में, कोड दिखाता है कि आप परिणाम प्राप्त करते हैं। कार्यात्मक दृष्टिकोण के साथ, " " timesTen() पद्धति में "लिपटा" है। बशर्ते कि यह विधि कहीं और लागू की गई थी, आप वास्तव में केवल numbers.timesTen() देख सकते हैं। numbers.timesTen() अभिव्यक्ति। ऐसा कोड स्पष्ट रूप से दिखाता कि इस कोड से हासिल किया गया है, न कि इस कार्य को हल किया जाता है। इसे डिक्लेरेटिव प्रोग्रामिंग कहा जाता है, और यह अनुमान लगाना आसान है कि ऐसा दृष्टिकोण आकर्षक क्यों है। अनिवार्य दृष्टिकोण डेवलपर को समझता है कोड को यह निर्धारित करने के लिए वह करना चाहिए, काम करता है। इंपीरियल दृष्टिकोण की तुलना में कार्यात्मक दृष्टिकोण बहुत अधिक "अभिव्यंजक" है और डेवलपर को केवल यह मानने का शानदार अवसर प्रदान करता है कि यह विधि क्या करने का दावा करती है! (जाहिर है, यह धारणा केवल पूर्व-सत्यापित कोड पर लागू होती है)।

2. यदि आपका कोड चल रहा है तो एक और thread numbers सरणी तक पहुंचने का प्रयास करता है तो क्या होता है?

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

इसकी तुलना में, कार्यात्मक दृष्टिकोण का कोई "दुष्प्रभाव" नहीं है। दूसरे शब्दों में, output पद्धति का output हमारे सिस्टम में किसी भी संग्रहीत मूल्यों को नहीं बदलता है और केवल इनपुट द्वारा निर्धारित किया जाता है। इस स्थिति में, किसी भी थ्रेड ( threads ) की numbers सरणी तक पहुंच होती है, ALWAYS को समान मान प्राप्त होंगे और इसका व्यवहार स्थिर और अनुमानित होगा।

3. यदि आप numbers सरणी में संग्रहीत मूल मूल्यों तक पहुंच चाहते हैं तो क्या होगा?

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

4. इस कोड का परीक्षण कितना विश्वसनीय हो सकता है?

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

लाभ का सारांश

जैसा कि हमने एक बहुत ही सरल उदाहरण से देखा, यदि आप एक डेटा मॉडल के साथ काम कर रहे हैं तो कार्यात्मक दृष्टिकोण एक अच्छी बात है:

• यह घोषणात्मक है
• यह race condition और गतिरोध जैसे धागे से संबंधित मुद्दों को ठीक करता है
• यह राज्य को अपरिवर्तित छोड़ देता है, जिसका उपयोग बाद के परिवर्तनों के लिए किया जा सकता है।
• यह परीक्षण करना आसान है।

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

प्रथम श्रेणी के कार्य और उच्चतर क्रम के कार्य

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

इस वजह से, हमारे पास Swift में अन्य कार्य हैं - उच्च-क्रम वाले फ़ंक्शन जिन्हें फ़ंक्शन के रूप में परिभाषित किया जाता है जो किसी अन्य फ़ंक्शन को तर्क के रूप में लेते हैं या फ़ंक्शन वापस करते हैं। उनमें से कई हैं: map , filter , reduce , forEach , flatMap , compactMap , sorted , आदि। उच्च क्रम के कार्यों के सबसे सामान्य उदाहरण हैं map , filter और reduce । वे वैश्विक नहीं हैं, वे कुछ विशेष प्रकार के "संलग्न" हैं। वे Collection सहित सभी Sequence प्रकारों पर काम करते हैं, जो Swift डेटा संरचनाओं जैसे कि Array , एक Dictionary और एक Set द्वारा दर्शाया गया है। Swift 5 , उच्च-क्रम के कार्य भी पूरी तरह से नए TYPE - Result साथ काम करते हैं।

map(_:)

Swift map(_:) एक फ़ंक्शन को पैरामीटर के रूप में लेता है और इस फ़ंक्शन के अनुसार एक निश्चित के मूल्यों को परिवर्तित करता है। उदाहरण के लिए, Array मानों के एक सरणी में map(_:) लागू करते हुए, हम मूल सरणी के प्रत्येक तत्व के लिए एक पैरामीटर फ़ंक्शन लागू करते हैं और हमें सरणी का एक सरणी मिलता है, लेकिन परिवर्तित मान, साथ ही।

 //Functional Approach let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] func timesTen(_ x:Int) -> Int { return x * 10 } let result = numbers.map (timesTen) print(numbers) //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(result) //[10, 20, 30, 40, 50, 60, 70, 80, 90, 100] 

उपरोक्त कोड में, हमने फ़ंक्शन timesTen (_:Int) , जो एक पूर्णांक Int मान लेता है और पूर्णांक मान को 10 गुणा करता है, और इसे हमारे उच्च-ऑर्डर map(_:) फ़ंक्शन के लिए इनपुट पैरामीटर के रूप में उपयोग करते हुए, इसे हमारे सरणी पर लागू करता है। numbers । result सरणी में हमें वह परिणाम चाहिए जो हमें चाहिए।

पैरामीटर फ़ंक्शन का नाम उच्च-क्रम के कार्यों के लिए लिया जाता है, जैसे कि map(_:) कोई फर्क नहीं पड़ता, इनपुट पैरामीटर और रिटर्न मान महत्वपूर्ण हैं, अर्थात, फ़ंक्शन (इनपुट) पैरामीटर के हस्ताक्षर (Int) -> Int । इसलिए, हम map(_:) में अनाम फ़ंक्शंस का उपयोग कर सकते हैं map(_:) - क्लोज़र - किसी भी रूप में, जिनमें संक्षिप्त तर्क नाम $0 , $1 , आदि शामिल हैं।

 //Functional Approach let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] let result = numbers.map { $0 * 10 } print(numbers) //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(result) //[10, 20, 30, 40, 50, 60, 70, 80, 90, 100] 

यदि हम एक Array लिए map(_ :) फ़ंक्शन देखें, तो यह इस तरह दिखाई दे सकता है:

 func map<T>(_ transform: (Element) -> T) -> [T] { var returnValue = [T]() for item in self { returnValue.append(transform(item)) } return returnValue } 

यह एक अनिवार्य कोड है जो हमारे लिए परिचित है, लेकिन यह अब एक डेवलपर समस्या नहीं है, यह एक Apple समस्या है, एक Swift समस्या है। उच्च-क्रम map(_:) फ़ंक्शन के कार्यान्वयन को प्रदर्शन के मामले में Apple द्वारा अनुकूलित किया गया है, और हम, डेवलपर्स, map(_:) गारंटी देते हैं map(_:) कार्यक्षमता, इसलिए हम केवल transform तर्क फ़ंक्शन के साथ सही ढंग से व्यक्त कर सकते हैं कि हम बारे में चिंता किए बिना चाहते हैं। इसे लागू किया जाएगा। नतीजतन, हमें एक पंक्ति के रूप में पूरी तरह से पठनीय कोड मिलता है, जो बेहतर और तेजी से काम करेगा।

 //Functional Approach let possibleNumbers = ["1", "2", "three", "///4///", "5"] let mapped = possibleNumbers.map {str in Int(str) } print (mapped) // [Optional(1), Optional(2), nil, nil, Optional(5)] 

पैरामीटर फ़ंक्शन द्वारा लौटाया गया मूल संग्रह में तत्वों के साथ मेल नहीं खा सकता है।

उपरोक्त कोड में, हमारे पास पूर्णांकों की संख्या possibleNumbers , स्ट्रिंग्स के रूप में प्रतिनिधित्व किया गया है, और हम उन्हें बंद करने के लिए { str in Int(str) } । हम map(_:) का उपयोग करते हैं map(_:) और आउटपुट के रूप में Optional का एक mapped सरणी प्राप्त करते हैं:



हम अपने सरणी possibleNumbers तत्वों को पूर्णांकों में परिवर्तित करने में सक्षम थे, परिणामस्वरूप, एक भाग को मान प्राप्त हुआ, String को पूर्णांक Int में परिवर्तित करने की असंभवता को दर्शाता है, और दूसरा भाग ऑप्टिक्स में बदल गया है, जिसमें मूल्य हैं:

 print (mapped) // [Optional(1), Optional(2), nil, nil, Optional(5)] 

compactMap(_ :)

यदि उच्च-क्रम फ़ंक्शन को दिए गए पैरामीटर फ़ंक्शन का आउटपुट पर एक Optional मान है, तो यह उच्च आदेश के किसी अन्य फ़ंक्शन का उपयोग करने के लिए अधिक उपयोगी हो सकता है जो अर्थ में समान है - compactMap(_ :) , जो map(_:) के समान कार्य करता है map(_:) , लेकिन इसके अलावा Optional आउटपुट में प्राप्त मूल्यों को "विस्तारित" करता है और संग्रह से nil मान निकालता है।



इस मामले में, हमें compactMapped टाइप की एक सरणी compactMapped [Int] , लेकिन संभवतः छोटी है:

 let possibleNumbers = ["1", "2", "three", "///4///", "5"] let compactMapped = possibleNumbers.compactMap(Int.init) print (compactMapped) // [1, 2, 5] 

जब भी आप init?() उपयोग करते हैं init?() compactMap(_ :) रूप में प्रारंभिक कार्य, आपको compactMap(_ :) का उपयोग करना होगा:

 // Validate URLs let strings = ["https://demo0989623.mockable.io/car/1", "https://i.imgur.com/Wm1xcNZ.jpg"] let validateURLs = strings.compactMap(URL.init) // Separate Numbers and Operations let mathString: String = "12-37*2/5+44" let numbers1 = mathString.components(separatedBy: ["-", "*", "+", "/"]).compactMap(Int.init) print(numbers1) // [12, 37, 2, 5, 44] 

मुझे यह कहना होगा कि उच्च-क्रम फ़ंक्शन compactMap(_ :) का उपयोग करने के लिए पर्याप्त से अधिक कारण हैं। Swift "प्यार" Optional मूल्यों, वे न केवल " failable " failable का उपयोग करके प्राप्त किया जा सकता है init?() failable , लेकिन यह भी के as? उपयोग करके as? "कास्टिंग" :

 let views = [innerView,shadowView,logoView] let imageViews = views.compactMap{$0 as? UIImageView} 

... और try? जब प्रसंस्करण त्रुटियों कुछ तरीकों से फेंक दिया। मुझे कहना होगा कि Apple चिंतित है कि try? का उपयोग try? बहुत बार डबल Optional ओर जाता है और स्विफ्ट 5 में अब try? करने के बाद केवल एक Optional स्तर छोड़ देता है try? ।

उच्च क्रम वाले flatMap(_ :) नाम पर एक और समान कार्य है, जिसके बारे में थोड़ा कम है।

कभी-कभी, उच्च-क्रम फ़ंक्शन map(_:) का उपयोग करने के लिए zip (_:, _:) दो अलग-अलग अनुक्रमों से जोड़े के अनुक्रम बनाने के लिए zip (_:, _:) विधि का उपयोग करना उपयोगी होता है।

मान लीजिए कि हमारे पास एक view है जिस पर कई बिंदुओं का प्रतिनिधित्व किया जाता है, एक साथ जुड़ा हुआ है और एक टूटी हुई रेखा बनती है:



हमें मूल टूटी रेखा के खंडों के मध्य बिंदुओं को जोड़ने वाली एक और टूटी हुई रेखा बनाने की आवश्यकता है:



किसी खंड के मध्य बिंदु की गणना करने के लिए, हमारे पास दो बिंदुओं का निर्देशांक होना चाहिए: वर्तमान और अगला। ऐसा करने के लिए, हम अंकों के जोड़े से मिलकर एक अनुक्रम बना सकते हैं - वर्तमान और अगला - zip (_:, _:) विधि का उपयोग करते हुए, जिसमें हम बिंदुओं के बिंदु का उपयोग करेंगे और निम्नलिखित बिंदुओं के सरणी का उपयोग करेंगे। points.dropFirst() :

 let pairs = zip (points,points.dropFirst()) let averagePoints = pairs.map { CGPoint(x: ($0.x + $1.x) / 2, y: ($0.y + $1.y) / 2 )} 

इस तरह के अनुक्रम के बाद, हम बहुत आसानी से उच्च-क्रम फ़ंक्शन map(_:) का उपयोग करके मिडपॉइंट की गणना करते हैं और उन्हें ग्राफ़ पर प्रदर्शित करते हैं।

filter (_:)

Swift , उच्च-क्रम फ़ंक्शन filter (_:) अधिकांश उपलब्ध है जिसके लिए map(_:) फ़ंक्शन उपलब्ध है। आप किसी भी Sequence दृश्यों को filter (_:) साथ filter (_:) कर सकते हैं, यह स्पष्ट है! filter (_:) विधि एक अन्य फ़ंक्शन को एक पैरामीटर के रूप में लेती है, जो अनुक्रम के प्रत्येक तत्व के लिए एक शर्त है, और यदि स्थिति संतुष्ट है, तो तत्व परिणाम में शामिल है, और यदि नहीं, तो यह शामिल नहीं है। यह "अन्य फ़ंक्शन" एक एकल मान लेता है - Sequence अनुक्रम का एक तत्व - और एक Bool लौटाता है, तथाकथित विधेय।

उदाहरण के लिए, Array सरणियों के लिए, उच्च-क्रम फ़ंक्शन filter (_:) विधेय फ़ंक्शन को लागू करता है और मूल सरणी के उन तत्वों से पूरी तरह से युक्त एक और सरणी देता है जिसके लिए इनपुट विधेय फ़ंक्शन true देता true ।

 //Functional Approach let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] let filted = numbers.filter{$0 % 2 == 0} //[2, 4, 6, 8, 10] 

यहां, उच्च-क्रम फ़ंक्शन filter (_:) numbers प्रत्येक तत्व को सरणी लेता है ( $0 द्वारा दर्शाया गया है) और यह देखने के लिए जांचें कि क्या यह तत्व समान संख्या है। यदि यह एक समान संख्या है, तो numbers सरणी के तत्व नए filted सरणी में आते हैं, अन्यथा नहीं। हमने एक घोषणात्मक रूप में कार्यक्रम को सूचित किया कि हम से एचओवी के बारे में देखभाल करना चाहते हैं, हमें इसे करना चाहिए।

मैं उच्च-क्रम फ़ंक्शन filter (_:) का उपयोग करने का एक और उदाहरण दूंगा filter (_:) मानों के साथ केवल पहले 20 फाइबोनैचि संख्याओं को प्राप्त करने के लिए < 4000 :

 let fibonacci = sequence(first: (0, 1), next: { ($1, $0 + $1) }) .prefix(20).map{$0.0} .filter {$0 % 2 == 0 && $0 < 4000} print (fibonacci) // [0, 2, 8, 34, 144, 610, 2584] 

हमें टिबल्स का एक अनुक्रम मिलता है जिसमें फिबोनाची अनुक्रम के दो तत्व होते हैं: n-th और (n + 1) -he:

 (0, 1), (1, 1), (1, 2), (2, 3), (3, 5) … 

आगे की प्रक्रिया के लिए, हम prefix (20) का उपयोग करते हुए तत्वों की संख्या को इक्कीसवें तत्व तक सीमित करते हैं और map {$0.0 } का उपयोग करके गठित टपल के 0 तत्व को लेते हैं, जो 0 शुरू होने वाले फाइबोनैचि अनुक्रम के अनुरूप होगा:

 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584,... 

हम map {$0.1 } का उपयोग करके गठित टपल का 1 तत्व ले सकते हैं, जो 1 साथ शुरू होने वाले फाइबोनैचि अनुक्रम के अनुरूप होगा:

 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584,... 

हमें उच्च-क्रम फ़ंक्शन filter {$0 % 2 == 0 && $0 < 4000} की सहायता से आवश्यक तत्व मिलते हैं, जो दिए गए विधेय को संतुष्ट करने वाले अनुक्रम तत्वों की एक सरणी देता है। हमारे मामले में, यह पूर्णांकों की एक सरणी होगी [Int] :

 [0, 2, 8, 34, 144, 610, 2584] 

Collection लिए filter (_:) का उपयोग करने का एक और उपयोगी उदाहरण है।

मुझे एक वास्तविक समस्या तब आई जब आपके पास CollectionView images का उपयोग करके प्रदर्शित images का एक समूह है, और आप Drag & Drop तकनीक का उपयोग करके images का एक पूरा "पैक" एकत्र कर सकते हैं और उन्हें "डंपिंग" सहित हर जगह स्थानांतरित कर सकते हैं कचरा कर सकते हैं। "



इस स्थिति में, "कचरा removedIndexes " में डंप किए गए removedIndexes के अनुक्रमित सूचकांक के सरणी को ठीक कर दिया जाता है, और आपको उन छवियों को एक नया सरणी बनाने की आवश्यकता होती है, जिन्हें छोड़कर उन सभी को हटा दिया जाता है जिनके सूचकांक सरणी में removedIndexes । मान लें कि हमारे पास पूर्णांक images की एक सरणी है जो images नकल करती है, और इन पूर्णांकों के सूचकांकों की एक सरणी हटा दी जाती है और जो हटाए जाने की आवश्यकता होती है। हम अपनी समस्या को हल करने के लिए filter (_:) का उपयोग करेंगे:

 var images = [6, 22, 8, 14, 16, 0, 7, 9] var removedIndexes = [2,5,0,6] var images1 = images .enumerated() .filter { !removedIndexes.contains($0.offset) } .map { $0.element } print (images1) // [22, 14, 16, 9] 

enumerated() विधि offset सूचकांकों और सरणी element मानों से मिलकर ट्यूपल्स का एक क्रम लौटाती है।फिर हम filterट्यूल के परिणामस्वरूप अनुक्रम के लिए एक फ़िल्टर लागू करते हैं , केवल उन लोगों को छोड़कर जिनके सूचकांक $0.offsetसरणी में निहित नहीं हैं removedIndexes। अगला कदम, हम टपल से मूल्य का चयन करते हैं $0.elementऔर हमें जिस सरणी की आवश्यकता होती है उसे प्राप्त करते हैं images1।

reduce (_:, _:)

विधि reduce (_:, _:)भी उपलब्ध map(_:)और विधियों के लिए उपलब्ध है filter (_:)। विधि reduce (_:, _:)" Sequenceएकल संचय मूल्य के लिए अनुक्रम" ढह जाती है और दो पैरामीटर हैं। पहला पैरामीटर शुरुआती संचय मूल्य है, और दूसरा पैरामीटर एक फ़ंक्शन है जो Sequenceनए संचय मूल्य प्राप्त करने के लिए अनुक्रम तत्व के साथ संचय मूल्य को जोड़ता है ।

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

 let sum = Array (1...100).reduce(0, +) 

यह एक उच्च क्रम फ़ंक्शन का उपयोग करने का एक उत्कृष्ट तुच्छ उदाहरण है reduce (_:, _:)- किसी सरणी के तत्वों का योग गिनना Array।

     1 0 1 0 +1 = 1 2 1 2 2 + 1 = 3 3 3 3 3 + 3 = 6 4 6 4 4 + 6 = 10 . . . . . . . . . . . . . . . . . . . 100 4950 100 4950 + 100 = 5050 

फ़ंक्शन का उपयोग करके, reduce (_:, _:)हम बहुत ही सरलता से फाइबोनैचि संख्याओं की गणना कर सकते हैं जो एक निश्चित स्थिति को संतुष्ट करते हैं:

 let fibonacci = sequence(first: (0, 1), next: { ($1, $0 + $1) }) .prefix(20).map{$0.0} .filter {$0 % 2 == 0 && $0 < 4000} print (fibonacci) // [0, 2, 8, 34, 144, 610, 2584] print(fibonacci.reduce(0,+)) // 3382 

लेकिन एक उच्च क्रम फ़ंक्शन के अधिक दिलचस्प अनुप्रयोग हैं reduce (_:, _:)।

उदाहरण के लिए, हम बहुत ही सरलतापूर्वक और संक्षिप्त रूप से इसके लिए बहुत महत्वपूर्ण पैरामीटर निर्धारित कर सकते हैं UIScrollView- "स्क्रॉल करने योग्य" क्षेत्र का contentSizeआकार - इसके विवरण के आधार पर subviews:

 let scrollView = UIScrollView() scrollView.addSubview(UIView(frame: CGRect(x: 300.0, y: 0.0, width: 200, height: 300))) scrollView.addSubview(UIView(frame: CGRect(x: 100.0, y: 0.0, width: 300, height: 600))) scrollView.contentSize = scrollView.subviews .reduce(CGRect.zero,{$0.union($1.frame)}) .size // (500.0, 600.0) 

इस डेमो में, संचय मूल्य है GCRect, और संचय ऑपरेशन unionआयतों के संयोजन का संचालन है जो frameहमारे हैं subviews।

इस तथ्य के बावजूद कि उच्च-क्रम फ़ंक्शन reduce (_:, _:)एक संचित चरित्र को मानता है, इसका उपयोग पूरी तरह से अलग परिप्रेक्ष्य में किया जा सकता है। उदाहरण के लिए, ट्यूपल की एक सरणी में एक टपल को भागों में विभाजित करने के लिए:

 // Separate Tuples let arr = [("one", 1), ("two", 2), ("three", 3), ("four", 4)] let (arr1, arr2) = arr.reduce(([], [])) { ($0.0 + [$1.0], $0.1 + [$1.1]) } print(arr1) // ["one", "two", "three", "four"] print(arr2) // [1, 2, 3, 4] 

स्विफ्ट 4.2ने एक नए प्रकार के उच्च क्रम फ़ंक्शन की शुरुआत की reduce (into:, _:)। विधि के reduce (into:, _:)साथ तुलना में दक्षता में बेहतर है , उदाहरण के लिए, या reduce (:, :)परिणामस्वरूप संरचना के रूप में प्रयोग किया जाता है । पूर्णांक की एक सरणी में मिलान मूल्यों को हटाने के लिए इसका प्रभावी रूप से उपयोग किया जा सकता है:COW (copy-on-write) ArrayDictionary

 // Remove duplicates let arrayInt = [1,1,2,6,6,7,2,9,7].reduce(into: []) { !$0.contains($1) ? $0.append($1) : () } // [1, 2, 6, 7, 9] 

... या सरणी में विभिन्न तत्वों की संख्या की गिनती करते समय:

 // Count equal elements in array let arrayIntCount = [1,1,2,2,6,6,7,2,9,7].reduce(into: [:]) { counts, letter in counts[letter, default: 0] += 1 } // [6: 2, 9: 1, 1: 2, 2: 3, 7: 2] 

flatMap (_:)

इस उच्च क्रम फ़ंक्शन पर जाने से पहले, आइए एक बहुत ही सरल डेमो देखें।

 let maybeNumbers = ["42", "7", "three", "///4///", "5"] let firstNumber = maybeNumbers.map (Int.init).first 

यदि हम इस कोड को निष्पादित करने के लिए चलाते हैं Playground, तो सब कुछ अच्छा दिखता है, और हमारा firstNumberसमान है 42:



लेकिन, यदि आप नहीं जानते हैं, तो यह Playgroundअक्सर सच को छुपाता है , विशेष रूप से स्थिर firstNumber। वास्तव में, स्थिरांक firstNumberमें दो चीजें होती हैं Optional:



यह इसलिए है क्योंकि map (Int.init)आउटपुट पर यह OptionalTYPE मानों की एक सरणी बनाता है [Int?], क्योंकि हर पंक्ति Stringको परिवर्तित करने में सक्षम नहीं है Intऔर इनिशलाइज़र Int.int"गिर रहा है" ( failable) है। फिर हम फ़ंक्शन का उपयोग का गठन सरणी के पहले तत्व लेने firstवालों के लिए Arrayहै, जो भी उत्पादन रूपोंOptional, क्योंकि सरणी खाली हो सकती है और हम सरणी का पहला तत्व प्राप्त करने में सक्षम नहीं होंगे। नतीजतन, हमारे पास एक डबल है Optional, जो है Int??।

हमें एक नेस्टेड संरचना Optionalमिली है Optionalजिसमें काम करना वास्तव में अधिक कठिन है और जिसे हम स्वाभाविक रूप से नहीं करना चाहते हैं। इस नेस्टेड संरचना से मूल्य प्राप्त करने के लिए, हमें दो स्तरों में "गोता" लगाना होगा। इसके अतिरिक्त, कोई भी अतिरिक्त परिवर्तन स्तर को और Optionalभी कम कर सकता है।

डबल नेस्टेड से बाहर मूल्य प्राप्त करना Optionalवास्तव में बोझ है।

हमारे पास 3 विकल्प हैं और उन सभी को भाषा के गहन ज्ञान की आवश्यकता है Swift।

• if let , ; «» «» Optional , — «» Optional :
  
  
• if case let ( pattern match ) :
  
  
  
  ?? :
  
  
• , switch :
  
  

इससे भी बदतर, सामान्यीकृत ( generic) कंटेनरों को शामिल करने वाली किसी भी स्थिति में ऐसी घोंसले के शिकार की समस्याएं उत्पन्न होती हैं , जिसके लिए एक ऑपरेशन को परिभाषित किया जाता है map। उदाहरण के लिए, सरणियों के लिए Array।

एक अन्य उदाहरण कोड पर विचार करें। मान लें कि हमारे पास एक बहु-पंक्ति पाठ है multilineStringजिसे हम लोअरकेस (छोटे) अक्षरों में लिखे शब्दों में विभाजित करना चाहते हैं:

 let multilineString = """  ,  ,   ;     , —  ,   :  —   ,   .   ,   ,   .    .  ,        ,  « »  .  ,  ,   ! """ let words = multilineString.lowercased() .split(separator: "\n") .map{$0.split(separator: " ")} 

शब्दों की एक सरणी प्राप्त करने के लिए words, हम पहले विधि का उपयोग करके अपरकेस (बड़े) अक्षरों को छोटा (छोटा) बनाते हैं lowercased(), फिर हम पाठ को विधि का उपयोग करते हुए split(separatot: "\n")लाइनों में विभाजित करते हैं और स्ट्रिंग का एक सरणी प्राप्त करते हैं, और फिर map {$0.split(separator: " ")}अलग-अलग शब्दों में प्रत्येक पंक्ति को अलग करने के लिए इसका उपयोग करते हैं।

परिणामस्वरूप, हमें नेस्टेड एरे मिलते हैं:

 [["", ",", "", ","], ["", "", ";", "", "", "", "", ",", "—"], ["", ",", "", "", ":"], ["", "—", "", "", ",", "", "", "."], ["", "", ",", "", "", ","], ["", "", ".", "", ""], ["", ".", "", ",", ""], ["", "", "", ""], ["", "", ",", "", "«", "»"], ["", ".", "", ","], ["", ",", "", "", "!"]] 

... और wordsएक डबल Array:



एक बार फिर, हम डेटा की एक "नेस्टेड" संरचना प्राप्त किया, लेकिन इस बार हम नहीं था Optional, और Array। यदि हम wordsउदाहरण के लिए, प्राप्त शब्दों को संसाधित करना जारी रखना चाहते हैं , उदाहरण के लिए, इस बहु-पंक्ति पाठ के पत्र स्पेक्ट्रम को खोजने के लिए, तो हमें पहले किसी तरह से डबल के सरणी को "सीधा" करना होगा Arrayऔर इसे एकल के एक सरणी में बदलना होगा Array। यह Optionalइस खंड की शुरुआत में एक डेमो के लिए डबल के साथ हमने क्या किया है flatMap:

 let maybeNumbers = ["42", "7", "three", "///4///", "5"] let firstNumber = maybeNumbers.map (Int.init).first 

सौभाग्य से, Swiftहमें जटिल वाक्य निर्माण का सहारा नहीं लेना पड़ेगा। Swiftसरणियों के लिए तैयार समाधान के साथ हमें आपूर्ति करता है Arrayऔर Optional। यह एक उच्च क्रम फ़ंक्शन है flatMap! यह बहुत समान है map, लेकिन इसमें "संलग्नक" के बाद के "सीधे" से जुड़ी अतिरिक्त कार्यक्षमता है जो निष्पादन के दौरान दिखाई देती है map। और इसीलिए इसे कहा जाता है flatMap, यह "सीधा" ( flattens) परिणाम है map।

आइए लागू flatMapकरने का प्रयास करें firstNumber:



हमें वास्तव में एकल स्तर के साथ आउटपुट मिला Optional। एक सरणी के लिए

और भी दिलचस्प flatMapकाम करता है Array। के लिए हमारी अभिव्यक्ति में, wordsहम बस के mapसाथ प्रतिस्थापित करते हैंflatMap:



... और हमें wordsबिना किसी "नेस्टिंग" के केवल शब्दों की एक सरणी मिलती है :

 ["", ",", "", ",", "", "", ";", "", "", "", "", ",", "—", "", ",", "", "", ":", "", "—", "", "", ",", "", "", ".", "", "", ",", "", "", ",", "", "", ".", "", "", "", ".", "", ",", "", "", "", "", "", "", "", ",", "", "«", "»", "", ".", "", ",", "", ",", "", "", "!"] 

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



हमें [Character]अपने बहु-पंक्ति वाक्यांश में निहित अक्षरों और प्रतीकों के "नेस्टेड" सरणी नहीं, एक एकल मिलता है :

 ["", "", "", "", "", "", "", "", "", "", "", "", ",", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ",", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ";", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ...] 

तथ्य यह है कि स्ट्रिंग पात्रों Stringका एक संग्रह है और, प्रत्येक व्यक्तिगत शब्द पर लागू होते हुए, हम एक बार फिर "नेस्टिंग" के स्तर को कम करते हैं और वर्णों की एक सरणी में आते हैं । शायद यह वही है जो आप चाहते हैं, या शायद नहीं। इस पर ध्यान दें।Collection[Character]flatMapflattenCharacters

यह सब एक साथ रखना: कुछ समस्याओं को हल करना

TASK १

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

 let wordsString = words.reduce ("",+).filter { "" .contains($0)} //  

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

हम इसे दो तरीकों से कर सकते हैं।
पहली विधिSwift 4.2 एक उच्च क्रम फ़ंक्शन की नई विविधता के उपयोग से जुड़ी है जो इसमें दिखाई दी है reduce (into:, _:)। letterCountहमारे बहु-पंक्ति वाक्यांश में अक्षरों की घटना की आवृत्ति के साथ एक शब्दकोश को व्यवस्थित करने के लिए यह विधि काफी उपयुक्त है :

 let letterCount = wordsString.reduce(into: [:]) { counts, letter in counts[letter, default: 0] += 1} print (letterCount) // ["": 1, "": 18, "": 2, "": 2, "": 5, "": 7, "": 17, "": 4, "": 23, ...] 

नतीजतन, हमें एक शब्दकोश मिलेगा letterCount [Character : Int]जिसमें चाबियाँ keyअध्ययन के तहत वाक्यांश में पाए जाने वाले वर्ण हैं, और मान के रूप valueमें इन वर्णों की संख्या है।

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

 let letterCountDictionary = Dictionary(grouping: wordsString ){ $0}.mapValues {$0.count} letterCount == letterCountDictionary // true 

हम शब्दकोश को letterCountवर्णानुक्रम में क्रमबद्ध करना चाहेंगे :

 let lettersStat = letterCountDictionary .sorted(by: <) .map{"\($0.0):\($0.1)"} print (lettersStat) // [":17", ":5", ":18", ":4", ":8", ":35", ":3", ":4", ":18", ":5", ":2", ":10", ":4", ":26", ":34", ":5", ":7", ":23", ":25", ":4", ":2", ":3", ":4", ":2", ":1", ":14", ":2", ":4"] 

लेकिन हम सीधे शब्दकोश को क्रमबद्ध नहीं कर सकते हैं Dictionary, क्योंकि यह मौलिक रूप से एक आदेशित डेटा संरचना नहीं है। यदि हम फ़ंक्शन sorted (by:)को शब्दकोश में लागू करते हैं Dictionary, तो यह हमारे लिए दिए गए अनुक्रम के तत्वों को नामित ट्यूपल्स के एक सरणी के रूप में दिए गए विधेय के साथ छांटेगा, जिसे mapहम [":17", ":5", ":18", ...]संबंधित अक्षर की घटना की आवृत्ति को दर्शाते हुए तारों के एक सरणी में बदल देते हैं ।

हम देखते हैं कि इस बार sorted (by:)बस " <" ऑपरेटर को एक उच्च-क्रम फ़ंक्शन के लिए एक विधेय के रूप में पारित किया गया है । फ़ंक्शन sorted (by:)इनपुट पर एकमात्र तर्क के रूप में "तुलना फ़ंक्शन" की अपेक्षा करता है। इसका उपयोग दो आसन्न मूल्यों की तुलना करने और यह तय करने के लिए किया जाता है कि क्या उन्हें सही तरीके से आदेश दिया गया है (इस मामले में, रिटर्नtrue) या नहीं (रिटर्न false)। हम इस "तुलनात्मक फ़ंक्शन" sorted (by:)को एक अनाम बंद के रूप में कार्य दे सकते हैं :

 sorted(by: {$0.key < $1.key} 

और हम इसे केवल ऑपरेटर " <" दे सकते हैं , जिसके पास हमारे हस्ताक्षर की आवश्यकता है, जैसा कि ऊपर किया गया था। यह भी एक फ़ंक्शन है, और कुंजी द्वारा छंटनी प्रगति पर है key।

अगर हम शब्दकोश को मूल्यों द्वारा क्रमबद्ध करना चाहते हैं valueऔर पता लगाना चाहते हैं कि इस वाक्यांश में कौन से अक्षर सबसे अधिक बार पाए जाते हैं, तो हमें फ़ंक्शन के लिए क्लोजर का उपयोग करना होगा sorted (by:):

 let countsStat = letterCountDictionary .sorted(by: {$0.value > $1.value}) .map{"\($0.0):\($0.1)"} print (countsStat ) //[":35", ":34", ":26", ":25", ":23", ":18", ":18", ":17", ":14", ":10", ":8", ":7", ":5", ":5", ":5", ":4", ":4", ":4", ":4", ":4", ":4", ":3", ":3", ":2", ":2", ":2", ":2", ":1"] 

अगर हम एक बहु के रूप में एक बहु वाक्यांश के पत्र स्पेक्ट्रम का निर्धारण करने की समस्या के समाधान पर एक नज़र डालें ...

 let multilineString = """  ,  ,   ;     , —  ,   :  —   ,   .   ,   ,   .    .  ,        ,  « »  .  ,  ,   ! """ let words = multilineString.lowercased() .split(separator: "\n") .flatMap{$0.split(separator: " ")} let wordsString = words.reduce ("",+).filter { "" .contains($0)} let letterCount = wordsString.reduce(into: [:]) { counts, letter in counts[letter, default: 0] += 1} let lettersStat = letterCountDictionary .sorted(by: <) .map{"\($0.0):\($0.1)"} print (lettersStat) // [":17", ":5", ":18", ":4", ":8", ":35", ":3", ":4", ":18", ":5", ":2", ":10", ":4", ":26", ":34", ":5", ":7", ":23", ":25", ":4", ":2", ":3", ":4", ":2", ":1", ":14", ":2", ":4"] let countsStat = letterCountDictionary .sorted(by: {$0.value > $1.value}) .map{"\($0.0):\($0.1)"} print (countsStat ) //[":35", ":34", ":26", ":25", ":23", ":18", ":18", ":17", ":14", ":10", ":8", ":7", ":5", ":5", ":5", ":4", ":4", ":4", ":4", ":4", ":4", ":3", ":3", ":2", ":2", ":2", ":2", ":1"] 

... हम ध्यान दें कि इस मार्ग में मौलिक कोड में कोई भी वेरिएबल (कोई var, केवल let)और वर्तमान (कुछ जानकारी का कार्य) को दर्शाती है, कैसे इन कार्यों कार्यान्वित कर रहे हैं के बारे में चिंता नहीं के कार्यों में से सभी के नाम:

split- विभाजन,
map- परिवर्तित
flatMapकरने के लिए परिवर्तित - संरेखण, (घोंसले में से एक स्तर को हटाने के द्वारा)
filter-, फिल्टर
sorted- छँटाई,
reduce- एक निश्चित संरचना में एक विशिष्ट आपरेशन के माध्यम से डेटा चालू करने के लिए

कोड की प्रत्येक पंक्ति के इस टुकड़ा में समारोह है कि हम का उपयोग करता है, तो हम में हैं के नाम बताते हैं। भरता "शुद्ध" परिवर्तन प्रयोग किया जाता है mapअगर हम प्रदर्शन नेस्टिंग स्तर के रूपांतरण प्रयोग किया जाता हैflatMap, अगर हम केवल कुछ डेटा का चयन करना चाहते हैं, तो हम उपयोग करते हैं filter, आदि "उच्चतम क्रम" के इन सभी कार्यों को Appleध्यान में रखते हुए डिज़ाइन किया गया है। तो कोड का यह टुकड़ा बहुत विश्वसनीय और संक्षिप्त है - हमें अपनी समस्या को हल करने के लिए 5 से अधिक वाक्यों की आवश्यकता नहीं थी। यह कार्यात्मक प्रोग्रामिंग का एक उदाहरण है।

इस डेमो में कार्यात्मक दृष्टिकोण को लागू करने का एकमात्र दोष यह है कि, अपरिवर्तनीयता, परीक्षणशीलता और पठनीयता के लिए, हम अपने पाठ को विभिन्न उच्च-क्रम के कार्यों के माध्यम से बार-बार पीछा करते हैं। बड़ी संख्या में संग्रह वस्तुओं के मामले में, Collectionप्रदर्शन गिर सकता है। उदाहरण के लिए, यदि हम पहले उपयोग करते हैं filter(_:)और, और फिर - first।
Swift 4 प्रदर्शन को बेहतर बनाने के लिए कुछ नए फीचर विकल्प जोड़े गए हैं, और यहां तेज कोड लिखने के लिए कुछ सुझाव दिए गए हैं।

1. उपयोग contains, नहींfirst( where: ) != nil

सत्यापित करना कि एक वस्तु एक संग्रह Collectionमें है, कई तरीकों से किया जा सकता है। सबसे अच्छा प्रदर्शन फ़ंक्शन द्वारा प्रदान किया जाता है contains।

सही कोड

 let numbers = [0, 1, 2, 3] numbers.contains(1) 

प्रोत्साहन कोड

 let numbers = [0, 1, 2, 3] numbers.filter { number in number == 1 }.isEmpty == false numbers.first(where: { number in number == 1 }) != nil 

2. सत्यापन का उपयोग करें isEmpty, countशून्य के साथ तुलना नहीं

चूंकि कुछ संग्रह के लिए संपत्ति के उपयोग को संग्रह के countसभी तत्वों पर पुनरावृति द्वारा किया जाता है।

सही कोड

 let numbers = [] numbers.isEmpty 

प्रोत्साहन कोड

 let numbers = [] numbers.count == 0 

3. के Stringसाथ खाली स्ट्रिंग की जाँच करेंisEmpty

स्ट्रिंग Stringइन Swiftकैरेक्टर्स का एक संग्रह है [Character]। इसका मतलब है कि स्ट्रिंग्स के लिए इसका Stringउपयोग करना बेहतर है isEmpty।

सही कोड

 myString.isEmpty 

प्रोत्साहन कोड

 myString == "" myString.count == 0 

4. पहले तत्व को प्राप्त करना जो कुछ शर्तों को पूरा करता है

संपूर्ण संग्रह पर Iterating पहली वस्तु को प्राप्त करने के लिए जो कुछ शर्तों को पूरा करती है, एक विधि के filterबाद एक विधि का उपयोग करके किया जा सकता है first, लेकिन गति के मामले में विधि सबसे अच्छी है first (where:)। जैसे ही यह आवश्यक स्थिति को पूरा करता है, यह विधि संग्रह पर पुनरावृति करना बंद कर देती है। विधि filterपूरे संग्रह पर पुनरावृत्ति करना जारी रखेगी, चाहे वह आवश्यक तत्वों से मिले या नहीं।

जाहिर है, विधि के लिए भी यही सच है last (where:)।

सही कोड

 let numbers = [3, 7, 4, -2, 9, -6, 10, 1] let firstNegative = numbers.first(where: { $0 < 0 }) 

प्रोत्साहन कोड

 let numbers = [0, 2, 4, 6] let allEven = numbers.filter { $0 % 2 != 0 }.isEmpty 

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

TASK 2

एक उच्च क्रम फ़ंक्शन के बहुत संक्षिप्त उपयोग का एक और शानदार उदाहरण है reduce (_:, _:)जो मैं भर में आया हूं। यह एक SET गेम है ।
यहाँ इसके मूल नियम हैं। खेल का नाम SETअंग्रेजी शब्द "सेट" - "सेट" से आता है। गेम SETमें 81 कार्ड शामिल हैं, प्रत्येक में एक अद्वितीय चित्र है:



प्रत्येक कार्ड में 4 विशेषताएँ हैं, जो नीचे सूचीबद्ध हैं:

मात्रा : प्रत्येक कार्ड में एक, दो या तीन वर्ण हैं।
पात्रों के प्रकार : अंडाकार, रंबल या तरंगें।
रंग : प्रतीक लाल, हरे या बैंगनी रंग के हो सकते हैं।
भरना : पात्र खाली, छायांकित या छायांकित हो सकते हैं।

खेल का उद्देश्यSET: टेबल पर रखे गए 12 कार्डों में से, आपको SET3 कार्डों से मिलकर (एक सेट) ढूंढना होगा , जिसमें से प्रत्येक चिन्ह या तो पूरी तरह से मेल खाता हो या सभी 3 कार्डों पर पूरी तरह से अलग हो। सभी संकेतों को इस नियम का पूरी तरह से पालन करना चाहिए।

उदाहरण के लिए, सभी 3 कार्ड पर पात्रों की संख्या होनी चाहिए सभी 3 कार्ड पर एक ही या अलग रंग या तो एक ही या अलग, और होना चाहिए इतने पर ...

इस उदाहरण में, हम कार्ड मॉडल में केवल रुचि कर रहे हैं SET struct SetCardऔर कलन विधि की परिभाषा SETके लिए 3 नक्शे isSet( cards:[SetCard]):

 struct SetCard: Equatable { let number: Variant // number - 1, 2, 3 let color: Variant // color - 1, 2, 3 (, , , ) let shape: Variant // symbol - 1, 2, 3 (, , , ) let fill: Variant // fill - 1, 2, 3 (, , , ) enum Variant: Int, CaseIterable { case v1 = 1 case v2 case v3 } static func isSet(cards: [SetCard]) -> Bool { guard cards.count == 3 else {return false} let sums = [ cards.reduce(0, { $0 + $1.number.rawValue }), cards.reduce(0, { $0 + $1.color.rawValue }), cards.reduce(0, { $0 + $1.shape.rawValue }), cards.reduce(0, { $0 + $1.fill.rawValue }) ] return sums.reduce(true, { $0 && ($1 % 3 == 0) }) } } 

मॉडल प्रत्येक सुविधा - संख्या number , प्रतीक प्रकार shape , रंग color और भरने fill - लिस्टिंग प्रस्तुत Variantतीन संभावित मान होने var1, var2और var33 पूर्णांक के लिए जो मेल खाती है rawValue- 1,2,3। इस रूप में, rawValueइसे संचालित करना आसान है। यदि हम कुछ संकेत लेते हैं, उदाहरण के लिए, colorतो 3 कार्ड के rawValueलिए सब कुछ जोड़कर colors, हम पाएंगे कि यदि colorsसभी 3 कार्ड समान हैं, तो योग समान होगा 3, 6या 9, यदि वे सभी अलग-अलग होंगे, तो योग होगा बराबर 6। इनमें से किसी भी मामले में, हमारे पास तीसरी राशि के rawValueलिए गुणा हैcolorsसभी 3 कार्ड। हम जानते हैं कि यह 3 कार्ड बनाने के लिए एक शर्त है SET। 3 कार्ड के लिए वास्तव में SETआवश्यक हो जाने के लिए, सभी संकेतों के लिए SetCard- मात्रा number, प्रतीक प्रकार shape, रंग colorऔर भरना fill- उनकी राशि rawValue3 की बहु होनी चाहिए ।

इसलिए, में staticविधि, isSet( cards:[SetCard])हम पहली सरणी गणना sumsरकम के rawValueसभी 4 प्रदर्शन नक्शा उच्च आदेश समारोह का उपयोग कर के लिए सभी 3 नक्शे के लिए reduceएक प्रारंभिक मूल्य के साथ करने के लिए बराबर 0है, और कार्यों जमा {$0 + $1.number.rawValue}, {$0 + $1.color.rawValue}, {$0 + $1.shape.rawValue}, { {$0 + $1.fill.rawValue}। सरणी का प्रत्येक तत्व sums3 का एक बहु होना चाहिए, और फिर से हम फ़ंक्शन का उपयोग करते हैंreduce, लेकिन इस बार trueतार्किक फ़ंक्शन " AND" के समान और संचय करने वाला प्रारंभिक मूल्य {$0 && ($1 % 3) == 0}। स्विफ्ट 5 अलग समारोह की बहुलता की जाँच के लिए शुरू की isMultiply(of:)ऑपरेटर के बजाय %विभाजन के शेष। यह भी कोड की पठनीयता में सुधार होगा: { $0 && ($1.isMultiply(of:3) }।

यह कल्पना करने के लिए कि कोड 3 SetCardकार्ड हैं, यह पता लगाने के लिए संक्षिप्त कोड SET" कार्यात्मक " दृष्टिकोण के लिए धन्यवाद प्राप्त किया गया है , और हम यह सुनिश्चित कर सकते हैं कि यह कैसे काम करता है Playground:



इस गेम मॉडल पर SETयूजर इंटरफेस ( UI) का निर्माण कैसे करें यहां , यहां और यहां ।

शुद्ध सुविधाएँ और दुष्प्रभाव

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

के लिए इस विषय Swiftसाइट पर उल्लिखित पूरी तरह से point.free के पहले एपिसोड में " कार्य " और " साइड इफेक्ट्स " है, जो में रूसी अनुवाद किया गया है और के रूप में प्रस्तुत " विकल्प " और "साइड इफेक्ट्स" ।

समारोह रचना

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

कल्पना कीजिए कि हमारे पास एक पूर्णांक है और हम आउटपुट पर विशिष्ट सम संख्याओं के एक वर्ग को प्राप्त करना चाहते हैं। आमतौर पर हम इसे इस प्रकार फिर से लागू करते हैं:

 var integerArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 4, 5] func unique(_ array: [Int]) -> [Int] { return array.reduce(into: [], { (results, element) in if !results.contains(element) { results.append(element) } }) } func even(_ array: [Int]) -> [Int] { return array.filter{ $0%2 == 0} } func square(_ array: [Int]) -> [Int] { return array.map{ $0*$0 } } var array = square(even(unique(integerArray))) // it returns [4, 16, 36, 64] 

यह कोड हमें सही परिणाम देता है, लेकिन आप देखते हैं कि कोड की अंतिम पंक्ति की पठनीयता इतनी आसान नहीं है। कार्यों का क्रम (दाएं से बाएं) उस के विपरीत है जिसके हम आदी हैं (बाएं से दाएं) और यहां देखना चाहेंगे। हमें अपने तर्क को पहले कई एम्बेडिंग के अंतरतम भाग तक निर्देशित करने की आवश्यकता है - एक सरणी के लिए inegerArray, फिर इस सरणी के लिए एक फ़ंक्शन बाहरी के लिए unique, फिर हम एक और स्तर तक जाते हैं - एक फ़ंक्शन even, और अंत में, एक फ़ंक्शन square।

और यहां फ़ंक्शंस >>>और ऑपरेटर्स की "रचना" हमारी सहायता के लिए आती है |>, जो हमें integerArrayफ़ंक्शन के "कन्वेयर" के रूप में मूल सरणी के प्रसंस्करण का प्रतिनिधित्व करते हुए, बहुत सुविधाजनक तरीके से कोड लिखने की अनुमति देती है :

 var array1 = integerArray |> unique >>> even >>> square 

लगभग सभी तरह के कार्यात्मक प्रोग्रामिंग के रूप में भाषाओं विशेष F#, Elixirऔर Elm"रचना" कार्यों के लिए इन ऑपरेटरों का उपयोग करें।

के रूप में Swiftवहाँ कोई ऑपरेटरों 'रचना "कार्यों में बनाया गया है >>>और |>, लेकिन हम मदद से बहुत आसानी से उन्हें प्राप्त कर सकते हैं Generics, सर्किट ( closure) और infixऑपरेटर:

 precedencegroup ForwardComposition{ associativity: left higherThan: ForwardApplication } infix operator >>> : ForwardComposition func >>> <A, B, C>(left: @escaping (A) -> B, right: @escaping (B) -> C) -> (A) -> C { return { right(left($0)) } } precedencegroup ForwardApplication { associativity: left } infix operator |> : ForwardApplication func |> <A, B>(a: A, f: (A) -> B) -> B { return f(a) } 

अतिरिक्त लागतों के बावजूद, कुछ मामलों में यह आपके कोड के प्रदर्शन, पठनीयता और परीक्षणशीलता को महत्वपूर्ण रूप से बढ़ा सकता है। उदाहरण के लिए, जब mapआप अंदर कई कार्यों के >>>माध्यम से "कंपोज़िशन" ऑपरेटर का उपयोग करके कार्यों की एक पूरी श्रृंखला रखते हैं , तो एक सरणी का पीछा करते हुए map:

 var integerArray1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 4, 5] let b = integerArray1.map( { $0 + 1 } >>> { $0 * 3 } >>> String.init) print (b) // ["6", "9", "12", "15", "18", "21", "24", "27", "30", "6", "15", "18"] 

लेकिन हमेशा एक कार्यात्मक दृष्टिकोण सकारात्मक प्रभाव नहीं देता है।

पहली बार, जब यह Swift2014 में दिखाई दिया , तो सभी ने कार्यों की "रचना" के लिए ऑपरेटरों के साथ पुस्तकालय लिखने के लिए भाग लिया और उस समय के लिए एक कठिन कार्य को हल किया जैसे कि JSONअसीम नेस्टेड निर्माणों का उपयोग करने के बजाय कार्यात्मक प्रोग्रामिंग ऑपरेटरों का उपयोग करना if let। मैंने खुद कार्यात्मक पार्सिंग के बारे में लेख का अनुवाद किया है जो JSON है जो मुझे इसके सुरुचिपूर्ण समाधान से प्रसन्न करता है और अर्गो पुस्तकालय का प्रशंसक था ।

लेकिन डेवलपर्स Swiftपूरी तरह से अलग तरीके से गए और प्रस्तावित किया गया, प्रोटोकॉल-उन्मुख तकनीक के आधार पर, कोड लिखने का एक बहुत अधिक संक्षिप्त तरीका। JSONडेटा को सीधे "डिलीवर" करने के लिएयह करने के लिए पर्याप्त Codableजो स्वचालित रूप से इस प्रोटोकॉल को लागू करता है, अपने मॉडल में जाना जाता है के होते हैं, तो Swift: डाटा संरचनाओं String, Int, URL, Array, Dictionary, आदि

 struct Blog: Codable { let id: Int let name: String let url: URL } 

JSONउस प्रसिद्ध लेख के डेटा होने के बाद ...

 [ { "id" : 73, "name" : "Bloxus test", "url" : "http://remote.bloxus.com/" }, { "id" : 74, "name" : "Manila Test", "url" : "http://flickrtest1.userland.com/" } ] 

... फिलहाल आपको ब्लॉग की एक सरणी प्राप्त करने के लिए कोड की एक पंक्ति की आवश्यकता है blogs:

 let blogs = Bundle.main.path(forResource: "blogs", ofType: "json") .map(URL.init(fileURLWithPath:)) .flatMap { try? Data.init(contentsOf: $0) } .flatMap { try? JSONDecoder().decode([Blog].self, from: $0) } print ("\(blogs!)") // [id: 73 name: Bloxus test url: http://remote.bloxus.com/, // id: 74 name: Manila Test url: http://flickrtest1.userland.com/] 

पार्सिंग के लिए "रचना" के कार्यों के ऑपरेटरों का उपयोग करने के बारे में हर कोई सुरक्षित रूप से भूल गया है JSON, अगर प्रोटोकॉल का उपयोग करके ऐसा करने के लिए एक और अधिक समझने योग्य और आसान तरीका है।

यदि सब कुछ इतना आसान है, तो हम JSONडेटा को और अधिक जटिल मॉडल में "अपलोड" कर सकते हैं । मान लें कि हमारे पास एक JSONडेटा फ़ाइल है जिसका नाम है user.jsonऔर हमारी निर्देशिका में स्थित है Resources.। इसमें एक निश्चित उपयोगकर्ता के बारे में डेटा है:

 { "email": "blob@pointfree.co", "id": 42, "name": "Blob" } 

और हमारे पास डेटा से इनिशलाइज़र वाला Codable उपयोगकर्ता है :Userjson

 struct User: Codable { let email: String let id: Int let name: String init?(json: Data) { if let newValue = try? JSONDecoder().decode(User.self, from: json) { self = newValue } else { return nil } } } 

हम बहुत ही newUserसरल कार्यात्मक कोड के साथ एक नया उपयोगकर्ता आसानी से प्राप्त कर सकते हैं :

 let newUser = Bundle.main.path(forResource: "user", ofType: "json") .map(URL.init(fileURLWithPath:)) .flatMap { try? Data.init(contentsOf: $0) } .flatMap { User.init(json: $0) } 

जाहिर है, newUserएक TYPE होगा Optional, अर्थात् User?:



मान लीजिए कि हमारी निर्देशिका में Resourcesएक नाम के साथ एक और फ़ाइल है invoices.jsonऔर इसमें इस उपयोगकर्ता के चालान पर डेटा है।

 [ { "amountPaid": 1000, "amountDue": 0, "closed": true, "id": 1 }, { "amountPaid": 500, "amountDue": 500, "closed": false, "id": 2 } ] 

हम इस डेटा को ठीक उसी तरह लोड कर सकते हैं जैसे हमने किया था User। आइए संरचना को चालान मॉडल के रूप में परिभाषित करें struct Invoice...

 struct Invoice: Codable { let amountDue: Int let amountPaid: Int let closed: Bool let id: Int } 

... और ऊपर प्रस्तुत JSONचालानों की सरणी को डीकोड करें invoices, केवल फ़ाइल पथ को बदलते हुए और तर्क को डिकोड करें decode:

 let invoices = Bundle.main.path(forResource: "invoices", ofType: "json") .map( URL.init(fileURLWithPath:) ) .flatMap { try? Data.init(contentsOf: $0) } .flatMap { try? JSONDecoder().decode([Invoice].self, from: $0) } 

invoicesहोगा [Invoice]?:



अब हम उपयोगकर्ता userको उसके चालान के साथ जोड़ना चाहेंगे invoices, यदि वे समान नहीं हैं nil, और सहेजते हैं, उदाहरण के लिए, लिफाफे की संरचना में, UserEnvelopeजो उपयोगकर्ता को उसके चालान के साथ भेजा जाता है:

 struct UserEnvelope { let user: User let invoices: [Invoice] } 

दो बार प्रदर्शन करने के बजाय if let...

 if let newUser = newUser, let invoices = invoices { } 

... चलो if letएक सहायक Genericफ़ंक्शन के रूप में डबल के एक कार्यात्मक एनालॉग को लिखते हैं zipजो दो Optionalमूल्यों को एक Optionalटुपल में परिवर्तित करता है :

 func zip<A, B>(_ a: A?, _ b: B?) -> (A, B)? { if let a = a, let b = b { return (a, b) } return nil } 

अब हमारे पास चर को कुछ निर्दिष्ट करने का कोई कारण नहीं है newUserऔर invoices, हम बस अपने नए फ़ंक्शन में सब कुछ बनाते zipहैं, इनिशलाइज़र का उपयोग करें UserEnvelope.initऔर सब कुछ काम करेगा!

 let userEnv = zip( Bundle.main.path(forResource: "user", ofType: "json") .map(URL.init(fileURLWithPath:)) .flatMap { try? Data.init(contentsOf: $0) } .flatMap { User.init(json: $0) }, Bundle.main.path(forResource: "invoices", ofType: "json") .map(URL.init(fileURLWithPath:)) .flatMap { try? Data.init(contentsOf: $0) } .flatMap { try? JSONDecoder().decode([Invoice].self, from: $0) } ).flatMap (UserEnvelope.init) print ("\(userEnv!)") // UserEnvelope(user: id: 42 name: Blob , // invoices: [id: 1 amountDue: 0 amountPaid: 1000 closed: true, // id: 2 amountDue: 500 amountPaid: 500 closed: false]) 

एक एकल अभिव्यक्ति में, संरचना के रूप में JSONएक जटिल एक को डेटा पहुंचाने के लिए एक संपूर्ण एल्गोरिथ्म पैक किया जाता है ।struct UserEnvelope

• zip , , . user , JSON , invoices , JSON . .
• map , , «» .
• flatMap , , , .

डेटा रूपांतरण के लिए एक प्रकार का डोमेन-विशिष्ट भाषा (DSL) का संचालन zip, प्रतिनिधित्व mapऔर flatMapप्रतिनिधित्व करता है ।

हम इस डेमो को एक विशेष फ़ंक्शन के रूप में एक फ़ाइल की सामग्री को पढ़ने के लिए अतुल्यकालिक रूप से प्रतिनिधित्व करने के लिए विकसित कर सकते हैं जिसे आप पॉइंटफ्री ..co पर देख सकते हैं ।

मैं हर जगह और हर जगह कार्यात्मक प्रोग्रामिंग का कट्टर प्रशंसक नहीं हूं , लेकिन इसका उदारवादी उपयोग मुझे उचित लगता है।

निष्कर्ष

मैं विभिन्न कार्यात्मक प्रोग्रामिंग का उदाहरण सुविधाओं दिया Swf, बॉक्स "की टी« बाहर उच्च क्रम कार्यों के उपयोग पर आधारित map, flatMap, reduce, filterऔर दृश्यों के लिए अन्य Sequence, Optionalऔर Result। वे कोड बनाने के "वर्कहॉर्स" हो सकते हैं, ,खासकर अगर मूल्य - संरचनाएं structऔर गणनाएं वहां शामिल हैं enum। एक iOSएप्लिकेशन डेवलपर को इस टूल का मालिक होना चाहिए।

पर एकत्र की गई सभी क़ौम Playground, पर पाया जा सकता Github । यदि आपको लॉन्च में कोई समस्या है Playground, तो आप इस लेख को देख सकते हैं:

"लॉन्चिंग सिम्युलेटर" और "रनिंग प्लेग्राउंड" संदेशों के साथ एक्सकोड प्लेग्राउंड "फ्रीज" त्रुटियों से कैसे छुटकारा पाएं।

संदर्भ:

Functional Programming in Swift: An Introduction.
An Introduction to Functional Programming in Swift.
The Many Faces of Flat-Map: Part 3
Inside the Standard Library: Sequence.map()
Practical functional programming in Swift