स्विफ्ट में काम करने के लिए एक त्वरित परिचय

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

फ़ंक्शन संरचना के पीछे मूल विचार एक फ़ंक्शन को दूसरे फ़ंक्शन के परिणाम पर लागू करना है। तो यह फ़ंक्शन को एक फ़ंक्शन में संयोजित करने की गणितीय अवधारणा है।

आरंभ करना

आइए गणितीय अवधारणा के साथ इसकी चर्चा करें। उपरोक्त आरेख में, "f" और "g" दो कार्य हैं। हम नीचे दिए गए कार्यों का प्रतिनिधित्व कर सकते हैं:

f: A -> Bg: B -> C

यदि हम इन दो कार्यों की रचना करते हैं, तो हम इसे "g o f" (आप f का g कह सकते हैं) के रूप में प्रस्तुत कर सकते हैं।

(g o f): A -> C such that (g o f)(a) = g(f(a)) for all a in A

आइए एक सरल उदाहरण के साथ इसे और अधिक एक्सप्लोर करने का प्रयास करें:

Let f(a) = 2a + 3 & g(a) = 3a + 5, then function composition

(g o f)(a) = g(f(a)) = 3(f(a)) + 5 = 3(2a + 3) + 5 = 6a + 14

यह अवधारणा न केवल गणित में लागू है - हम इसे प्रोग्रामिंग भाषाओं में भी लागू कर सकते हैं। उन भाषाओं को फंक्शनल प्रोग्रामिंग लैंग्वेज कहा जाता है। इस अवधारणा को समझने से आपके कोड की पठनीयता में सुधार होता है और अन्य प्रोग्रामर के लिए इसे समझना आसान हो जाता है।

एक कार्यात्मक प्रोग्रामिंग भाषा के रूप में स्विफ्ट का परिचय

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

फ़ंक्शन संरचना को तेज़ी से कार्यान्वित करना

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

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

तो उपरोक्त सभी समस्याओं से हमें बचाने के लिए यहां फंक्शन कंपोजिशन आता है। हम जेनरिक, क्लोजर और इंफिक्स ऑपरेटर का लाभ उठाकर फंक्शन कंपोजिशन हासिल कर सकते हैं।

तो आइए देखें कि कोड के उपरोक्त ब्लॉक में क्या हो रहा है:

1. हमने एक कस्टम इंफिक्स ऑपरेटर ">>>" घोषित किया है। इसने + ऑपरेटर की तरह ही संबद्धता और वरीयता क्रम छोड़ दिया है।
2. हमने एक फ़ंक्शन घोषित किया है जिसका नाम इंफिक्स ऑपरेटर के नाम के समान है। फ़ंक्शन तीन जेनरिक T, U, V का उपयोग करता है और यह इनपुट पैरामीटर के रूप में दो क्लोजर लेता है।
3. बायां पैरामीटर एक क्लोजर है, और यह टाइप टी का इनपुट लेता है और टाइप यू का आउटपुट देता है।
4. सही पैरामीटर भी एक क्लोजर है, और यह टाइप U का इनपुट लेता है और टाइप V का आउटपुट देता है।
5. अब,>>> फ़ंक्शन एक फ़ंक्शन या क्लोजर देता है, जिसमें (टी) → वी का प्रकार होता है। आउटपुट क्लोजर टाइप टी का इनपुट लेता है और टाइप वी का आउटपुट देता है। यहां बाईं ओर का आउटपुट पैरामीटर सही पैरामीटर का इनपुट है।

left :  (T) -> U right: (U) -> V

Output Type: (T) -> V

यदि आप फ़ंक्शन संरचना के गणितीय प्रतिनिधित्व को समझते हैं, तो आप देख सकते हैं कि यह स्विफ्ट के कार्यान्वयन के साथ बिल्कुल वैसा ही है।

6. फ़ंक्शन बॉडी में, यह बाएं पैरामीटर पर दाएं पैरामीटर का परिणाम देता है।

अब अगर हम एक ही परिणाम चाहते हैं (अद्वितीय सम पूर्णांकों का एक वर्ग सरणी), तो हम इसे फ़ंक्शन संरचना के साथ कर सकते हैं।

यह कार्यों की एक श्रृंखला है जो समान परिणाम देता है। फ़ंक्शन ऑर्डर अब वैसा ही दिखता है जैसा कोई इंसान सोच सकता है। इसमें बेहतर पठनीयता है और सभी के लिए समझना आसान है।

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