एक फ़ंक्शन कुछ इनपुट लेता है, उसके साथ कुछ करता है और एक आउटपुट बनाता है। एक फ़ंक्शन का एक सिग्नेचर और एक बॉडी होता है। यदि आप एक फ़ंक्शन को वही इनपुट देते हैं तो आपको हमेशा वही आउटपुट मिलता है। संक्षेप में फ़ंक्शन की परिभाषा यही है।
अब हम फ़ंक्शन्स के बारे में अधिक बात करेंगे उनमें करीब से देखकर। हम Swift में हायर-ऑर्डर फ़ंक्शन्स का पता लगाएंगे। एक फ़ंक्शन जो दूसरे फ़ंक्शन को इनपुट के रूप में लेता है या एक फ़ंक्शन लौटाता है उसे हायर-ऑर्डर फ़ंक्शन कहा जाता है।
Swift में, हम हर दिन map, filter, reduce के साथ खेलते हैं। जब हम इन फ़ंक्शन्स का उपयोग करते हैं, तो यह जादू जैसा लगता है। इस बिंदु पर, आपके पास पर्दे के पीछे क्या हो रहा है इसका कोई विचार नहीं हो सकता है। Map, Filter, और Reduce फंक्शनल प्रोग्रामिंग के विचारों और दृष्टिकोणों के माध्यम से काम करते हैं। भले ही Swift एक शुद्ध फंक्शनल भाषा नहीं है, यह आपको फंक्शनल चीजें करने की अनुमति देता है।
अब आइए एक-एक करके देखें कि उनके लिए पृष्ठभूमि में क्या हो रहा है। पहले हम इन फ़ंक्शन्स के बुनियादी संस्करणों को कुछ विशेष डेटा प्रकारों के लिए लागू करेंगे, फिर हम एक जेनेरिक संस्करण को लागू करने का प्रयास करेंगे।
Map फ़ंक्शन
मान लें हमारे पास पूर्णांकों की एक सरणी है और हमें एक फ़ंक्शन लिखने की आवश्यकता है जो मूल सरणी के प्रत्येक एलिमेंट में कुछ डेल्टा मान जोड़ने के बाद एक नई सरणी लौटाता है। हम इसे नीचे की तरह एक साधारण for लूप का उपयोग करके आसानी से एक फ़ंक्शन लिख सकते हैं:
अब हमें एक और फ़ंक्शन की आवश्यकता है जो मूल सरणी के प्रत्येक एलिमेंट को दोगुना करके एक नई सरणी लौटाता है। इसके लिए, हम इसे नीचे की तरह लागू कर सकते हैं:
यदि हम उपरोक्त दो फ़ंक्शन्स को देखते हैं, तो हम पा सकते हैं कि वे मूल रूप से एक ही काम कर रहे हैं। केवल for लूप के अंदर की कार्यक्षमता अलग है। वे दोनों इनपुट के रूप में एक Integer सरणी लेते हैं, for लूप का उपयोग करके प्रत्येक एलिमेंट को ट्रांसफॉर्म करते हैं, और एक नई सरणी लौटाते हैं। तो मूल रूप से मुख्य बात प्रत्येक एलिमेंट को कुछ नया में ट्रांसफॉर्म करना है।
चूंकि Swift हायर-ऑर्डर फ़ंक्शन्स का समर्थन करता है, हम एक फ़ंक्शन लिख सकते हैं जो पूर्णांकों की एक सरणी, ट्रांसफॉर्म फ़ंक्शन को इनपुट के रूप में लेता है, और मूल सरणी के प्रत्येक एलिमेंट पर ट्रांसफॉर्म फ़ंक्शन लागू करके एक नई सरणी लौटाता है।
लेकिन फिर भी, उपरोक्त के साथ एक समस्या है: यह केवल एक पूर्णांक सरणी लौटाता है। यदि हमारे पास इनपुट पूर्णांक सरणी को स्ट्रिंग सरणी में बदलने की आवश्यकता है, उदाहरण के लिए, तो हम इस फ़ंक्शन के साथ ऐसा नहीं कर सकते। ऐसा करने के लिए, हमें एक जेनेरिक फ़ंक्शन लिखने की आवश्यकता है जो किसी भी प्रकार के लिए काम करता है।
हम एक Array एक्सटेंशन में एक जेनेरिक फ़ंक्शन को इस तरह लागू कर सकते हैं:
- Array एक्सटेंशन में एक map फ़ंक्शन घोषित करें जो जेनेरिक प्रकार T के साथ काम करता है।
- फ़ंक्शन (Element) ->; T प्रकार के फ़ंक्शन को इनपुट के रूप में लेता है
- फ़ंक्शन के अंदर एक खाली परिणाम सरणी घोषित करें जो T प्रकार का डेटा रखती है।
- खुद पर पुनरावृति करने वाला एक for लूप लागू करें और एलिमेंट को प्रकार T में बदलने के लिए ट्रांसफॉर्म फ़ंक्शन को कॉल करें
- परिवर्तित मान को परिणाम सरणी में जोड़ें
यही तरीका है जिससे Swift में map फ़ंक्शन काम करता है। यदि हमें map फ़ंक्शन, लागू करने की आवश्यकता है, तो हम इसे ऊपर की तरह लागू करेंगे। तो मूल रूप से, यह एक सरणी में कोई जादू नहीं करता — हम आसानी से फ़ंक्शन को स्वयं परिभाषित कर सकते थे।
Filter फ़ंक्शन
मान लें हमारे पास पूर्णांकों की एक सरणी है और हम सरणी में केवल सम संख्याओं को रखना चाहते हैं। हम इसे एक साधारण for लूप का उपयोग करके लागू कर सकते हैं:
अब फिर से, मान लें हमारे पास एक प्रोजेक्ट की क्लास फ़ाइल नामों का प्रतिनिधित्व करने वाली स्ट्रिंग्स की एक सरणी है और हम केवल .swift फ़ाइलों को रखना चाहते हैं। इसे नीचे की तरह एक लूप के साथ भी किया जा सकता है:
यदि हम उपरोक्त दो फ़ंक्शन्स के कार्यान्वयन को करीब से देखते हैं, तो हम समझ सकते हैं कि वे मूल रूप से एक ही काम करते हैं — केवल दो सरणियों के लिए डेटा प्रकार अलग है। हम इसे एक जेनेरिक filter फ़ंक्शन लागू करके सामान्यीकृत कर सकते हैं, जो एक सरणी और एक फ़ंक्शन को इनपुट के रूप में लेता है, और includeElement फ़ंक्शन के आउटपुट के आधार पर, यह तय करता है कि एलिमेंट को परिणाम सरणी में जोड़ना है या नहीं।
Reduce फ़ंक्शन
मान लें हमारे पास पूर्णांकों की एक सरणी है और हम दो फ़ंक्शन्स लागू करना चाहते हैं जो एलिमेंट्स का योग और गुणनफल लौटाते हैं। हम इसे एक साधारण for लूप का उपयोग करके लागू कर सकते हैं:
अब पूर्णांकों की सरणी होने के बजाय, मान लें हमारे पास स्ट्रिंग्स की एक सरणी है और हम सरणी में सभी एलिमेंट्स को जोड़ना चाहते हैं:
सभी तीन फ़ंक्शन्स मूल रूप से एक ही काम करते हैं। वे इनपुट के रूप में एक सरणी लेते हैं, एक परिणाम चर इनिशियलाइज़ करते हैं, सरणी पर पुनरावृति करते हैं, और परिणाम चर को अपडेट करते हैं।
यहां से हम एक जेनेरिक फ़ंक्शन लागू कर सकते हैं जो सभी के लिए काम करना चाहिए। ऐसा करने के लिए हमें परिणाम चर का प्रारंभिक मान और उस चर को हर पुनरावृत्ति में अपडेट करने का फ़ंक्शन चाहिए।
तो हम निम्न परिभाषा के साथ जेनेरिक फ़ंक्शन को लागू कर सकते हैं:
उपरोक्त कार्यान्वयन किसी भी इनपुट सरणी के प्रकार [Element]. के लिए जेनेरिक है। यह प्रकार T का परिणाम गणना करेगा। काम करने के लिए, इसे परिणाम चर को असाइन करने के लिए प्रकार T के प्रारंभिक मान की आवश्यकता होती है। फिर, इसे प्रकार (T, Element) -> T के फ़ंक्शन की आवश्यकता होती है जिसका उपयोग for लूप के अंदर प्रत्येक पुनरावृत्ति में परिणाम चर को अपडेट करने के लिए किया जाएगा।
