स्विफ्ट में जेनरिक की शक्ति। भाग 1

सभी को नमस्कार! हम आपके साथ विशेष रूप से पाठ्यक्रम “iOS डेवलपर” के छात्रों के लिए तैयार किए गए अनुवाद को साझा कर रहे हैं । उन्नत पाठ्यक्रम । ” अच्छी पढाई हो।



सामान्य कार्य, सामान्य प्रकार और प्रकार प्रतिबंध

क्या हैं जेनरिक?

जब वे काम करते हैं, तो आप उन्हें प्यार करते हैं, और जब नहीं, तो आप उनसे नफरत करते हैं!

वास्तविक जीवन में, हर कोई जेनरिक की शक्ति को जानता है: सुबह उठना, निर्णय लेना कि क्या पीना है, एक कप भरना।
️
स्विफ्ट एक प्रकार की सुरक्षित भाषा है। जब भी हम प्रकारों के साथ काम करते हैं, हमें उन्हें स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता होती है। उदाहरण के लिए, हमें एक फ़ंक्शन की आवश्यकता है जो एक से अधिक प्रकार के साथ काम करेगा। स्विफ्ट में Any और AnyObject प्रकार हैं, लेकिन उनका उपयोग सावधानी से किया जाना चाहिए और हमेशा नहीं। Any और AnyObject का उपयोग करना आपके कोड को अविश्वसनीय बना देगा, क्योंकि संकलन के दौरान प्रकार के बेमेल को ट्रैक करना असंभव होगा। यह वह जगह है जहाँ जेनेरिक बचाव के लिए आते हैं।

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

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

 let intArray = [1, 2, 3, 4] let stringArray = [a, b, c, d] func printInts(array: [Int]) { print(intArray.map { $0 }) } func printStrings(array: [String]) { print(stringArray.map { $0 }) } 

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

स्विफ्ट में जेनरिक का इतिहास

सामान्य कार्य

जेनेरिक फ़ंक्शन T किसी भी सार्वभौमिक पैरामीटर के साथ काम कर सकता है T टाइप नाम कहता है कि क्या होना चाहिए, इस बारे में कुछ नहीं है, लेकिन यह कहता है कि दोनों एरे टाइप होने चाहिए, भले ही क्या हो। बजाय स्वयं का उपयोग करने का प्रकार हर बार print( _: ) फ़ंक्शन कहा जाता है।

 func print<T>(array: [T]) { print(array.map { $0 }) } 

सामान्य प्रकार या पैरामीट्रिक बहुरूपता

ऊपर दिए गए उदाहरण से जेनेरिक टाइप T एक प्रकार का पैरामीटर है। आप कई प्रकार के पैरामीटर निर्दिष्ट कर सकते हैं, कोमा कोष्ठक द्वारा अलग किए गए कोण कोष्ठक में कई प्रकार के पैरामीटर नाम लिखकर।

यदि आप ऐरे और डिक्शनरी <Key, Element> को देखते हैं, तो आप देखेंगे कि उन्होंने टाइप पैरामीटर, अर्थात्, एलीमेंट और की, एलीमेंट, का नाम दिया है, जो टाइप पैरामीटर और जेनेरिक प्रकार या फ़ंक्शन के बीच संबंध की बात करता है, जिसमें इसका उपयोग किया जाता है ।

नोट: हमेशा CamelCase संकेतन (उदाहरण के लिए, T और TypeParameter ) में पैरामीटर टाइप करने के लिए नाम दें, यह दिखाने के लिए कि वे टाइप के लिए एक नाम हैं, न कि मान।

सामान्य प्रकार

ये कस्टम कक्षाएं, संरचनाएं, और गणनाएं हैं जो सरणियों और शब्दकोशों के समान किसी भी प्रकार के साथ काम कर सकती हैं।

चलो एक स्टैक बनाते हैं

 import Foundation enum StackError: Error { case Empty(message: String) } public struct Stack { var array: [Int] = [] init(capacity: Int) { array.reserveCapacity(capacity) } public mutating func push(element: Int) { array.append(element) } public mutating func pop() -> Int? { return array.popLast() } public func peek() throws -> Int { guard !isEmpty(), let lastElement = array.last else { throw StackError.Empty(message: "Array is empty") } return lastElement } func isEmpty() -> Bool { return array.isEmpty } } extension Stack: CustomStringConvertible { public var description: String { let elements = array.map{ "\($0)" }.joined(separator: "\n") return elements } } var stack = Stack(capacity: 10) stack.push(element: 1) stack.push(element: 2) print(stack) stack.pop() stack.pop() stack.push(element: 5) stack.push(element: 3) stack.push(element: 4) print(stack) 

अब यह स्टैक केवल पूर्णांक तत्वों को स्वीकार करने में सक्षम है, और अगर मुझे एक अलग प्रकार के तत्वों को संग्रहीत करने की आवश्यकता है, तो मुझे या तो एक और स्टैक बनाने की आवश्यकता होगी, या इसे एक सामान्य रूप में परिवर्तित करना होगा।

 enum StackError: Error { case Empty(message: String) } public struct Stack<T> { var array: [T] = [] init(capacity: Int) { array.reserveCapacity(capacity) } public mutating func push(element: T) { array.append(element) } public mutating func pop() -> T? { return array.popLast() } public func peek() throws -> T { guard !isEmpty(), let lastElement = array.last else { throw StackError.Empty(message: "Array is empty") } return lastElement } func isEmpty() -> Bool { return array.isEmpty } } extension Stack: CustomStringConvertible { public var description: String { let elements = array.map{ "\($0)" }.joined(separator: "\n") return elements } } var stack = Stack<Int>(capacity: 10) stack.push(element: 1) stack.push(element: 2) print(stack) var strigStack = Stack<String>(capacity: 10) strigStack.push(element: "aaina") print(strigStack) 

सामान्य प्रकार की सीमाएँ

चूँकि जेनेरिक किसी भी प्रकार का हो सकता है, आप इसके साथ बहुत कुछ नहीं कर सकते। कई बार बाधाओं को उन प्रकारों पर लागू करना उपयोगी होता है जिनका उपयोग सामान्य कार्यों या सामान्य प्रकारों के साथ किया जा सकता है। प्रकार प्रतिबंध संकेत देते हैं कि टाइप पैरामीटर को एक विशिष्ट प्रोटोकॉल या प्रोटोकॉल संरचना से मेल खाना चाहिए।

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

 func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) { // function body goes here } 

अनिवार्य रूप से, हमने टाइप टी का एक स्टैक बनाया है, लेकिन हम दो स्टैक की तुलना नहीं कर सकते हैं, क्योंकि यहां प्रकार Equatable मेल नहीं खाते हैं। हमें Stack< T: Equatable > का उपयोग करने के लिए इसे बदलना होगा।

कैसे काम करती है जेनरिक? आइए एक उदाहरण देखें।

 func min<T: Comparable>(_ x: T, _ y: T) -> T { return y < x ? y : x } 

कंपाइलर में फंक्शन कोड बनाने के लिए दो चीजों की कमी होती है:

• प्रकार टी के चर के आकार;
• फ़ंक्शन के विशिष्ट अधिभार के पते <, जिसे रन टाइम पर कॉल किया जाना चाहिए।

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

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

पहले भाग का अंत। परंपरा से, हम आपकी टिप्पणियों, मित्रों की प्रतीक्षा कर रहे हैं।

दूसरा भाग