👸🏽 ➕ 🕴🏼 स्विफ्ट 5.1 - नया क्या है? 🐎 🛵 🚜

स्विफ्ट 5.0 एक्सकोड 10.2 के रिलीज के साथ उपलब्ध हो गया, लेकिन अगले संस्करण पर काम जारी है और इसमें पहले से ही खबर है कि आप इसमें क्या उम्मीद कर सकते हैं।

स्विफ्ट 5.1 की एक प्रमुख विशेषता मॉड्यूल स्थिरता है , जो हमें इस बात की परवाह किए बिना तीसरे पक्ष के पुस्तकालयों का उपयोग करने की अनुमति देती है कि स्विफ्ट कंपाइलर के किस संस्करण के साथ वे बनाए गए थे। ऐसा लगता है कि हमें स्विफ्ट 5.0 में मिला एबीआई स्थिरता , लेकिन थोड़ा अंतर है: एबीआई स्थिरता रनटाइम में स्विफ्ट संस्करणों में अंतर का समाधान करती है, और संकलन समय पर मॉड्यूल स्थिरता।

इस महत्वपूर्ण नवाचार के अलावा, हम स्विफ्ट में कई महत्वपूर्ण सुधार प्राप्त करेंगे, और इस लेख में हम उन उदाहरणों के साथ जाएंगे, ताकि आप उन्हें कार्रवाई में देख सकें।

सार्वभौमिक स्व

SE-0068 स्व के उपयोग का विस्तार करता है, जिससे कि यह वर्गों, संरचनाओं और गणना के भीतर वाले प्रकार को संदर्भित करता है। यह आमतौर पर गतिशील प्रकारों के लिए उपयोगी होता है, जब रनटाइम पर किसी चीज के सटीक प्रकार को निर्धारित करना आवश्यक होता है।

एक उदाहरण के रूप में, निम्नलिखित कोड पर विचार करें:

class NetworkManager { class var maximumActiveRequests: Int { return 4 } func printDebugData() { print("Maximum network requests: \(NetworkManager.maximumActiveRequests).") } }

यहाँ हम NetworkManager वर्ग के अंदर स्थैतिक गुण को अधिकतमअनुकूलित करते हैं और इस संपत्ति को प्रिंट करने के लिए PrintDebugData () विधि जोड़ते हैं। यहां सब कुछ ठीक है, लेकिन केवल तब तक जब तक हम NetworkManager से वारिस नहीं हो जाते:

 class ThrottledNetworkManager: NetworkManager { override class var maximumActiveRequests: Int { return 1 } }

इस उत्तराधिकारी में, हम अधिकतमअनुकूलित संपत्ति को बदल देते हैं ताकि अब यह एक के बराबर हो जाए, लेकिन अगर हम प्रिंटड्यूगडेटा () कहते हैं , तो यह मूल वर्ग से मूल्य को कम कर देगा:

 let manager = ThrottledNetworkManager() manager.printDebugData()

यहां हमें 4 के बजाय 1 प्राप्त करना चाहिए, और यहां बचाव SE-0068 आता है: हम वर्तमान प्रकार को संदर्भित करने के लिए स्वयं (राजधानी 'एस' के साथ) का उपयोग कर सकते हैं। तो अब हम इस तरह के मूल वर्ग के PrintDebugData () विधि को फिर से लिख सकते हैं:

 class ImprovedNetworkManager { class var maximumActiveRequests: Int { return 4 } func printDebugData() { print("Maximum network requests: \(Self.maximumActiveRequests).") } }

यही है, स्व उसी तरीके से काम करता है जिस तरह से यह स्विफ्ट के पुराने संस्करणों में प्रोटोकॉल में काम करता था।

अस्पष्टता के लिए चेतावनी कोई नहीं

स्विफ्ट में वैकल्पिक को दो विकल्पों के साथ गणना के रूप में लागू किया जाता है: कुछ और कोई नहीं । यह भ्रम पैदा कर सकता है अगर हम अपनी खुद की गणना करें जिसका कोई विकल्प नहीं है और इसे वैकल्पिक में लपेटें। उदाहरण के लिए:

 enum BorderStyle { case none case solid(thickness: Int) }

गैर-वैकल्पिक का उपयोग करते समय सब कुछ साफ है:

 let border1: BorderStyle = .none print(border1)

यह "कोई नहीं" आउटपुट होगा। लेकिन अगर हम इस गणना के लिए वैकल्पिक का उपयोग करते हैं, तो हम एक समस्या का सामना करेंगे:

 let border2: BorderStyle? = .none print(border2)

निल यहाँ मुद्रित किया जाएगा, क्योंकि स्विफ्ट का मानना है कि .none का अर्थ है वैकल्पिक खाली है , हालांकि यह BorderStyle.none के मूल्य के साथ वास्तव में वैकल्पिक है।
स्विफ्ट 5.1 में, इस तरह की अस्पष्टता के मामले में, एक चेतावनी प्रदर्शित की जाएगी:
"आप 'Opt..one' मतलब है मान लें; क्या आपको इसके बजाय 'BorderStyle.none' से मतलब था? "
इस प्रकार, डेवलपर को सूचित किया जाएगा कि उसके कोड के साथ सब कुछ सुचारू नहीं हो सकता है।

वैकल्पिक और गैर-वैकल्पिक गणनाओं का मिलान करना

स्विफ्ट वैकल्पिक / गैर-वैकल्पिक पाठ और पूर्णांक मानों के संयोजन पर स्विच / केस निर्माण को समझने के लिए पर्याप्त स्मार्ट है, लेकिन गणना के मामले में नहीं।

अब स्विफ्ट 5.1 में हम एन्यूमरेशन-वैकल्पिक और गैर-वैकल्पिक विकल्पों के मिलान के लिए स्विच / केस का उपयोग कर सकते हैं:

 enum BuildStatus { case starting case inProgress case complete } let status: BuildStatus? = .inProgress switch status { case .inProgress: print("Build is starting…") case .complete: print("Build is complete!") default: print("Some other build status") }

स्विफ्ट गैर-वैकल्पिक विकल्पों के लिए वैकल्पिक गणना को मैप करने में सक्षम है, और "बिल्ड शुरू हो रहा है ..." यहां प्रदर्शित किया जाएगा।

आदेशित संग्रह की तुलना करें

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

मूल सिद्धांत सरल है - स्विफ्ट 5.1 एक नई विधि अंतर प्रदान करता है (:) से , जो दो ऑर्डर किए गए संग्रहों के बीच के अंतर को निर्धारित करता है - कौन से तत्व जोड़ना है और कौन सा निकालना है। यह किसी भी ऑर्डर किए गए संग्रह पर लागू होता है जिसमें समतुल्य प्रोटोकॉल का अनुपालन करने वाले आइटम होते हैं।

इसे प्रदर्शित करने के लिए, हम मानों के दो सरणियों का निर्माण करेंगे, एक से दूसरे के मतभेदों की गणना करेंगे, और फिर अंतरों की सूची के माध्यम से जाएंगे और उन्हें दो संग्रह समान बनाने के लिए लागू करेंगे।

नोट: चूंकि स्विफ्ट को अब Apple के ऑपरेटिंग सिस्टम के हिस्से के रूप में वितरित किया गया है, इसलिए नए कोड का उपयोग #available चेक के साथ किया जाना चाहिए ताकि यह सुनिश्चित हो सके कि कोड OS पर चलता है जो आवश्यक कार्यक्षमता का समर्थन करता है। भविष्य में जारी किए जा सकने वाले अज्ञात, अघोषित ओएस पर चलने वाली कार्यक्षमता के लिए, एक विशेष संस्करण संख्या का उपयोग किया जाता है, "9999", जिसका अर्थ है: "हम अभी तक सही संस्करण संख्या नहीं जानते हैं"।

 var scores1 = [100, 91, 95, 98, 100] let scores2 = [100, 98, 95, 91, 100] if #available(iOS 9999, *) { let diff = scores2.difference(from: scores1) for change in diff { switch change { case .remove(let offset, _, _): scores1.remove(at: offset) case .insert(let offset, let element, _): scores1.insert(element, at: offset) } } print(scores1) }

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

मतभेदों को मैन्युअल रूप से लागू करने के बजाय, आप एक के बाद एक नए आवेदन () विधि का उपयोग करके उन्हें एक झपट्टा में लागू कर सकते हैं:

 if #available(iOS 9999, *) { let diff = scores2.difference(from: scores1) let result = scores1.applying(diff) ?? [] }

Uninitialized Arrays बनाना

SE-0245 ने सरणियों के लिए एक नया इनिशियलाइज़र पेश किया जो इसे डिफ़ॉल्ट मानों से नहीं भरता है। यह पहले एक निजी एपीआई के रूप में उपलब्ध था, जिसका मतलब था कि कोडकोड ने इसे कोड पूरा करने में संकेत नहीं दिया, लेकिन आप इसका उपयोग कर सकते हैं यदि आपको इसकी आवश्यकता है और आप जोखिम को समझ गए हैं कि यह कार्यक्षमता भविष्य में नहीं हो सकती है।

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

उदाहरण के लिए, हम इस तरह के 10 यादृच्छिक पूर्णांक बना सकते हैं:

 let randomNumbers = Array<Int>(_unsafeUninitializedCapacity: 10) { buffer, initializedCount in for x in 0..<10 { buffer[x] = Int.random(in: 0...10) } initializedCount = 10 }

कई नियम हैं:

आपको आपके द्वारा अनुरोध किए गए पूरे वॉल्यूम का उपयोग करने की आवश्यकता नहीं है, लेकिन आप इसे पार नहीं कर सकते। यही है, यदि आप सरणी का आकार 10 तक सेट करते हैं, तो आप 0 से 10 तक रेंज में इनिशियलाइज़डाउन सेट कर सकते हैं, लेकिन 11 तक।
यदि आपने सरणी में उपयोग किए गए तत्वों को आरंभीकृत नहीं किया है, उदाहरण के लिए, आपने 5 के लिए initializedCount सेट किया है, लेकिन 4 के माध्यम से तत्वों 0 को वास्तविक मान प्रदान नहीं किया है, तो वे सबसे अधिक संभावना यादृच्छिक मान प्राप्त करेंगे। जैसा कि आप जानते हैं, यह एक बुरा विकल्प है।
यदि आप initializedCount सेट नहीं करते हैं, तो यह 0 के बराबर होगा और आपके द्वारा असाइन किया गया सभी डेटा खो जाएगा।

हां, हम मानचित्र का उपयोग करके कोड को फिर से लिख सकते हैं () :

 let randomNumbers2 = (0...9).map { _ in Int.random(in: 0...10) }

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

निष्कर्ष

स्विफ्ट 5.1 अभी भी विकास के अधीन है, और हालांकि स्विफ्ट के लिए अंतिम शाखा स्वयं पारित हो गई है, कुछ अन्य संबंधित परियोजनाओं से परिवर्तन अभी भी दिखाई दे रहे हैं।

इसलिए, सबसे महत्वपूर्ण परिवर्तन मॉड्यूल स्थिरता है , और यह ज्ञात है कि विकास टीम इस पर कड़ी मेहनत कर रही है। उन्होंने सटीक रिलीज़ की तारीख नहीं दी, हालांकि उन्होंने कहा कि स्विफ्ट 5.1 में स्विफ्ट 5.0 की तुलना में काफी कम विकास समय था, जिसके लिए ऊर्जा और ध्यान की असाधारण एकाग्रता की आवश्यकता थी। हम WWDC19 तक पहुँच प्राप्त कर सकते हैं, लेकिन यह स्पष्ट है कि जब मामला आपको एक निश्चित तारीख को चलाने की आवश्यकता हो तो ऐसा नहीं है।

एक और बिंदु जो ध्यान देने योग्य है। इस सूची में दो परिवर्तन ("बिना विकल्प के अस्पष्टता के मामले में चेतावनी" और "वैकल्पिक और गैर-वैकल्पिक गणनाओं का मिलान") स्विफ्ट के विकास का परिणाम नहीं थे, लेकिन उन्हें बग और समायोजित के रूप में मान्यता दी गई थी।