स्विफ्ट 5 - लंबे समय से प्रतीक्षित रिलीज, जिसमें कई दर्जन सुधार और सुधार शामिल हैं। लेकिन स्विफ्ट 5.0 की रिलीज का मुख्य लक्ष्य एबीआई स्थिरता प्राप्त करना था। इस लेख में, आप सीखेंगे कि ABI क्या है और ABI iOS / macOS डेवलपर्स को क्या स्थिर देगा। हम स्विफ्ट 5 की कई नई विशेषताओं का भी विश्लेषण करेंगे।

एबीआई स्थिरता

ABI एक बाइनरी एप्लिकेशन इंटरफ़ेस है। एक एबीआई को नियमों के एक सेट के रूप में माना जा सकता है जो संकलक को संकलित घटक मॉड्यूल को संयोजित करने की अनुमति देता है।

तदनुसार, एबीआई में निम्नलिखित वर्णित है।

1. जिस तरह से सिस्टम मॉड्यूल सहित विभिन्न मॉड्यूल से कोड कहा जाता है।
2. तर्कों को पारित करने और फ़ंक्शंस से रिटर्न वैल्यू प्राप्त करने का प्रारूप।
3. रैम डेटा लेआउट एल्गोरिदम।
4. मेमोरी प्रबंधन, एआरसी।
5. टाइप सिस्टम, जेनरिक।

स्विफ्ट 5, स्थिर एबीआई के साथ, अनुप्रयोगों के लिए द्विआधारी संगतता प्रदान करता है। IOS / macOS अनुप्रयोगों के लिए द्विआधारी संगतता का मतलब है कि संकलित अनुप्रयोग भाषा के पहले या बाद के संस्करणों द्वारा संकलित सिस्टम लाइब्रेरी के साथ रनटाइम में संगत होंगे। उदाहरण के लिए, स्विफ्ट 5.0 के साथ संकलित एक एप्लिकेशन स्विफ्ट 5.1 या स्विफ्ट 6.0 के साथ संकलित मानक पुस्तकालयों के साथ संगत होगा।

IOS 12.2 और macOS 10.14.4 के साथ शुरू, Apple के ऑपरेटिंग सिस्टम में सब कुछ होगा जिसमें आपको स्विफ्ट एप्लिकेशन चलाने होंगे। इसका मतलब है कि स्विफ्ट 5 में लिखे गए एप्लिकेशन और बाद में रनटाइम और एक मानक भाषा पुस्तकालय नहीं होगा। इसलिए, स्विफ्ट 5 में लिखे गए एप्लिकेशन का वजन लगभग 3-10 मेगाबाइट कम होगा।

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

ABI स्थिरता के पेशेवरों।

1. अनुप्रयोगों कम वजन होगा।
2. स्टार्टअप और एप्लिकेशन के प्रदर्शन में तेजी।
3. सिद्धांत रूप में, Apple पूरी तरह से स्विफ्ट पर नई रूपरेखा लिख ​​सकता है।

विपक्ष एबीआई स्थिरता।

डेवलपर्स को मानक पुस्तकालय के पुराने संस्करणों में किसी भी नई कार्यक्षमता की कमी पर विचार करना होगा। उदाहरण के लिए, यदि मानक पुस्तकालय में किसी भी नए वर्गों / कार्यों के साथ स्विफ्ट 5.1 iOS 13 में बनाया गया है, तो iOS 12.2 एप्लिकेशन में समर्थन के साथ, डेवलपर्स उनका उपयोग नहीं कर पाएंगे। (आपको फाउंडेशन, यूआईकिट और अन्य प्लेटफॉर्म लाइब्रेरी के लिए उसी तरह से # अवेलेबल (...) चेक डालने होंगे।

मानक पुस्तकालय में परिणाम प्रकार

अतुल्यकालिक एपीआई में त्रुटियों को संचारित करने और संभालने का एक मानक तरीका मानक पुस्तकालय में दिखाई दिया है। आप इस प्रकार का भी उपयोग कर सकते हैं यदि किसी कारणवश मानक त्रुटि से निपटने की कोशिश / पकड़ हमें शोभा नहीं देती है।

परिणाम प्रकार दो मामलों के साथ enum के माध्यम से लागू किया जाता है: सफलता और विफलता:

public enum Result<Success, Failure> where Failure: Error { case success(Success) case failure(Failure) ... } 

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

लेख डाउनलोड सेवा का उपयोग करने का एक उदाहरण:

 struct Article { let title: String } class ArticleService { func fetchArticle(id: Int64, completion: @escaping (Result<Article, Error>) -> Void) { //    // ... completion(.success(Article(title: "Swift 5.0.  ?"))) } } 

और यहां परिणाम को संसाधित करने का एक उदाहरण है। चूंकि परिणाम सिर्फ एक एनम है, हम इसके सभी राज्यों को एक स्विच के साथ संसाधित कर सकते हैं:

 articleService.fetchArticle(id: 42) { result in switch result { case .success(let article): print("Success: \(article)") case .failure(let error): print("Failure: \(error)") } } 

कच्चे तार

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

उद्धरण का उपयोग करने का एक उदाहरण:

 // swift 4.2 print("    \"\"   .") print("     ,    \\n") // swift 5 print(#" ""      "#) print(#"     ,    \n"#) 

नियमित अभिव्यक्ति लिखते समय यह सुविधा विशेष रूप से उपयोगी है:

 // swift 4.2 let regex = "^\\(*\\d{3}\\)*( |-)*\\d{3}( |-)*\\d{4}$" // swift 5 let regex = #"^\(*\d{3}\)*( |-)*\d{3}( |-)*\d{4}$"# 

बैकस्लैश के बाद लाइनों को प्रक्षेपित करने के लिए, # वर्ण जोड़ें:

 // swift 4.2 let string = "   \(variable)" // swift 5 let string = #"   \#(variable)"# 

आप इस वाक्य में अधिक पढ़ सकते हैं।

अद्यतन लाइन प्रक्षेप

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

 extension DefaultStringInterpolation { mutating func appendInterpolation(price: Decimal) { let formatter = NumberFormatter() formatter.numberStyle = .currency if let string = formatter.string(from: price as NSDecimalNumber) { appendLiteral(string) } else { appendLiteral(price.description) } } } print("Price of item: \(price: 9.99)") // Price of item: $9.99 

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

आप इस वाक्य में अधिक पढ़ सकते हैं।

संख्याओं की बहुलता की जाँच करना

बहुलता की जांच करने की विधि हैमौल्ट (मानक की) को पुस्तकालय में संख्यात्मक प्रकारों में जोड़ा गया है। हां, हम अभी भी शेष% का हिस्सा लेने के लिए ऑपरेटर का उपयोग कर सकते हैं। लेकिन ऐसा लगता है कि Multiple (में से :) अधिक दृश्य दिखता है।

 let interger = 42 if interger.isMultiple(of: 3) { print(" ") } else { print("  ") } 

शब्दकोश में CompactMapValues ​​विधि

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

उदाहरण के लिए, URL प्रकार के लिए स्ट्रिंग कुंजियों की मैपिंग:

 let dict = [ "site": "https://www.site.ru/path/to/web/site/page", "other site": "invalid url" ] let mappedDict: [String: URL] = dict.compactMapValues { URL(string: $0) } print(mappedDict) // ["site": https://www.site.ru/path/to/web/site/page] 

दूसरी कुंजी / मान जोड़ी को मैपिंग के बाद हटा दिया गया था, क्योंकि स्ट्रिंग एक मान्य URL नहीं है।

व्यवहार बदलने की कोशिश करें?

कोशिश निर्माण का उपयोग करके स्विफ्ट 4.2 में? आप आसानी से घोंसले के शिकार के स्तर के साथ एक वैकल्पिक प्रकार प्राप्त कर सकते हैं। ज्यादातर मामलों में, यह वह नहीं है जो डेवलपर को उम्मीद है। इस कारण से, स्विफ्ट 5 में प्रयास करें? ग वैकल्पिक चाइनिंग के समान व्यवहार मिला। यही है, कोशिश के संयोजन के साथ? वैकल्पिक चेनिंग या वैकल्पिक कास्टिंग के साथ, अभिव्यक्ति का परिणाम घोंसले के एक स्तर के साथ एक वैकल्पिक होगा।

उदाहरण का प्रयास करें? साथ में:

 // Swift 4.2 let jsonDict = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] //  jsonDict - [String: Any]?? // Swift 5 let jsonDict = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] //  jsonDict - [String: Any]? 

उदाहरण का प्रयास करें? एक साथ वैकल्पिक वस्तु विधि के साथ:

 // Swift 4.2 let article = try? storage?.getArticle() //  article - Article?? //  if let first = article, let second = first { first //  Article? second //  Article } //   if case let value?? = article { value //  Article } // Swift 5 let article = try? storage?.getArticle() //  article - Article? //  if let value = article { value //  Article } 

आप इस वाक्य में अधिक पढ़ सकते हैं।

@ डायनामिक कॉल करने योग्य विशेषता

नई @dynamicCallable विशेषता आपको "कॉल करने योग्य" के रूप में चिह्नित करने की अनुमति देती है। इसका मतलब है कि हम टाइप को सामान्य विधि कह सकते हैं।
यदि हम @dynamicCallable के रूप में टाइप करते हैं, तो हमें विधियों में से एक (या दोनों) को लागू करना होगा:

 func dynamicallyCall(withArguments: <#Arguments#>) -> <#R1#> func dynamicallyCall(withKeywordArguments: <#KeywordArguments#>) -> <#R2#> 

तर्क प्रकार ExpressibleByArrayLiteral प्रोटोकॉल का समर्थन करना चाहिए, KeywordArguments प्रकार को ExpressibleByDictionaryLiteral प्रोटोकॉल का समर्थन करना चाहिए, और R1 और R2 किसी भी प्रकार का हो सकता है।

उदाहरण के लिए, सम की संरचना। जब आप इसे कॉल करते हैं, तो आप किसी भी संख्या को स्थानांतरित कर सकते हैं और उनकी राशि प्राप्त कर सकते हैं:

 @dynamicCallable struct Sum { func dynamicallyCall(withArguments args: [Int]) -> Int { return args.reduce(0, +) } } let sum = Sum() let result = sum(1, 2, 3, 4) print(result) // 10 

वास्तव में, कंपाइलर राशि (1, 2, 3, 4) को कॉल में sum.dynamicallyCall (withArguments: [1, 2, 3, 4]) में परिवर्तित करता है। इसी तरह डायनामिक रूप से (withKeywordArguments :) विधि।

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

आप इस वाक्य में अधिक पढ़ सकते हैं।

संकलक संस्करण और भाषा की जांच के निर्देशों में कम ऑपरेटर समर्थन

स्विफ्ट के 5 वें संस्करण से शुरू होकर, आप कोड में कंपाइलर संस्करण की जांच करते समय "कम" ऑपरेटर का उपयोग कर सकते हैं:

 // Swift 4.2 #if !swift(>=5) //        4.2   #endif // Swift 5 #if swift(<5) //        4.2   #endif 

निष्कर्ष

ये सभी विशेषताएं और सुधार नहीं हैं जो स्विफ्ट 5 में दिखाई दिए। कुल मिलाकर, समुदाय से 28 प्रस्तावों को स्वीकार किया गया, जिसमें लाइन प्रदर्शन में सुधार, स्विफ्ट पैकेज मैनेजर में सुधार और मानक पुस्तकालय भी शामिल थे। परिवर्तन और सुधार की पूरी सूची जारी नोटों में पाई जा सकती है।