स्विफ्ट: प्रमुख मूल्यों को संचय करने के लिए कंटेनर

कल्पना करें कि आपको UserDefaults में यूजर आईडी को बचाने की आवश्यकता है। पहला कदम क्या होगा?

आमतौर पर, एक व्यवसाय एक कुंजी के लिए एक निरंतर जोड़ने और इसकी विशिष्टता के लिए जाँच करके शुरू होता है। यह अधिकांश अन्य कुंजी-मूल्य स्टोर के लिए सही है। और इस तरह के रिपोजिटरी के आदिम डिजाइन के परिणाम कुंजी तक सीमित नहीं हैं; विधियों के एक अनिश्चित सेट के रूप में एक इंटरफेस संभव समस्याओं की संख्या की ओर जाता है:

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

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

भंडारण प्रोटोकॉल

तो, पहली चीज जो हमें चाहिए वह है रिपॉजिटरी के लिए एक प्रोटोकॉल, जो अपने प्रकार से अमूर्त करने में मदद करेगा। इसलिए, हमारे पास UserDefaults , और एक चाबी का गुच्छा के साथ और कुछ अन्य कुंजी-मूल्य संग्रहण के साथ काम करने के लिए एक एकल इंटरफ़ेस होगा। यह प्रोटोकॉल बहुत सरल दिखता है:

 protocol KeyValueStorage { func value<T: Codable>(forKey key: String) -> T? func setValue<T: Codable>(_ value: T?, forKey key: String) } 

तो कोई भी स्टोरेज जो कि KeyValueStorage प्रोटोकॉल के अनुरूप है, उसे दो सामान्य तरीकों को लागू करना होगा: स्ट्रिंग के रूप में कुंजी मानों का गेटटर और सेटर। उसी समय, मान स्वयं Codable प्रोटोकॉल के अनुरूप Codable हैं, जो उन प्रकार के उदाहरणों को संग्रहीत करने की अनुमति देता है जिनका सार्वभौमिक प्रतिनिधित्व होता है (उदाहरण के लिए, JSON या प्रॉपर्टीलिस्ट )।

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

प्रोटोकॉल कार्यान्वयन

KeyValueStorage प्रोटोकॉल को लागू करने के दो तरीके हैं:

• प्रोटोकॉल के तहत मौजूदा भंडारण पर हस्ताक्षर करें और आवश्यक तरीके जोड़ें:

 extension UserDefaults: KeyValueStorage { func value<T: Codable>(forKey key: String) -> T? { //   } func setValue<T: Codable>(_ value: T?, forKey key: String) { //   } } 

• भंडारण को एक अलग प्रकार में लपेटें, बाहरी उपयोग के लिए अपने खेतों को छिपाएं:

 class PersistentStorage: KeyValueStorage { private let userDefaults: UserDefaults let suiteName: String? let keyPrefix: String init?(suiteName: String? = nil, keyPrefix: String = "") { guard let userDefaults = UserDefaults(suiteName: suiteName) else { return nil } self.userDefaults = userDefaults self.suiteName = suiteName self.keyPrefix = keyPrefix } func value<T: Codable>(forKey key: String) -> T? { //   } func setValue<T: Codable>(_ value: T?, forKey key: String) { //   } } 

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

तरीकों के value(forKey:) को लागू करने के लिए value(forKey:) और setValue(:forKey:) डेटा संगतता के लिए प्रदान करना महत्वपूर्ण है। यह आवश्यक है ताकि मानक UserDefaults उपकरण द्वारा संग्रहीत मान KeyValueStorage , और इसके विपरीत के तरीकों से पुनर्प्राप्त किए जा सकें।

रेडी-टू- PersistentStorage वर्ग का एक पूरा उदाहरण यहाँ उपलब्ध है ।

मूल्य कंटेनर

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

 class KeyValueContainer<T: Codable> { let storage: KeyValueStorage let key: String var value: T? { get { storage.value(forKey: key) } set { storage.setValue(newValue, forKey: key) } } init(storage: KeyValueStorage, key: String) { self.storage = storage self.key = key } } 

कंटेनर के लिए मूल्य प्रकार उसी तरह Codable प्रोटोकॉल द्वारा सीमित होता है जैसे कि स्टोर के तरीकों में ही होता है, इसलिए गणना की गई संपत्ति बस एक निश्चित कुंजी और मूल्य प्रकार के साथ कॉल करती है।

यदि आप चाहें, तो आप कंटेनर की कार्यक्षमता का विस्तार कर सकते हैं, उदाहरण के लिए, डिफ़ॉल्ट मान जोड़ें जिसका उपयोग स्टोर में कुंजी के लिए कोई डेटा नहीं होने पर किया जाएगा।

 class KeyValueContainer<T: Codable> { let storage: KeyValueStorage let key: String let defaultValue: T? var value: T? { get { storage.value(forKey: key) ?? defaultValue } set { storage.setValue(newValue, forKey: key) } } init(storage: KeyValueStorage, key: String, defaultValue: T? = nil) { self.storage = storage self.key = key self.defaultValue = defaultValue } } 

कंटेनर हमारी पहली दो समस्याओं को हल करता है - यह डेटा को पढ़ने और लिखने के लिए कुंजी और प्रकार को ठीक करता है। तो एक गलत प्रकार के मूल्य को लिखने का कोई भी प्रयास कंपाइलर द्वारा बिल्ड स्टेज पर रोका जाएगा:

 func doSomething(with container: KeyValueContainer<Int>) { container.value = "Text" //   } 

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

मुख्य विशिष्टता

संघर्ष की समस्या को हल करने के लिए, हम गणना की गई संपत्ति के नाम का उपयोग करते हैं जिसमें कंटेनर खुद कुंजी के रूप में बनाया जाएगा। ऐसा करने के लिए, हमारे KeyValueStorage प्रोटोकॉल में एक साधारण एक्सटेंशन जोड़ें:

 extension KeyValueStorage { func makeContainer<T: Codable>(key: String = #function) -> KeyValueContainer<T> { KeyValueContainer(storage: self, key: key) } } 

तो भंडारण प्रोटोकॉल के सभी कार्यान्वयन में, एक सामान्य विधि जोड़ी जाएगी जो निर्दिष्ट कुंजी के साथ एक कंटेनर लौटाती है। इस पद्धति में विशेष रुचि key पैरामीटर है, जो डिफ़ॉल्ट रूप से विशेष अभिव्यक्ति #function ( प्रलेखन ) के बराबर मूल्य है। इसका मतलब है कि बिल्ड स्टेज पर, #function शाब्दिक #function घोषणा के नाम से प्रतिस्थापित किया जाता है जिसमें से makeContainer(key:) विधि कहा जाता था।

यह निर्माण आपको भंडारण एक्सटेंशन में कंटेनरों की घोषणा करने की अनुमति देता है, और उनके नाम परिकलित गुणों के नाम होंगे यदि makeContainer() विधि को उनमें key पैरामीटर के बिना कहा जाता है:

 extension PersistentStorage { var foobar: KeyValueContainer<Int> { makeContainer() } } 

उदाहरण में, PersistentStorage संग्रहण उदाहरणों को कंटेनर के लिए उसी नाम के foobar कुंजी के साथ foobar संपत्ति प्राप्त होगी, जिसका मूल्य प्रकार एक पूर्णांक होगा। भंडारण के लिए दूसरा foobar कंटेनर जोड़ने का प्रयास करने से संकलन त्रुटि हो जाएगी, जो हमें कुंजियों की विशिष्टता की गारंटी देती है।

संक्षेप में देना

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

अलग-अलग, ऐसे कंटेनरों को जोड़ने और उपयोग करने की सुविधा ध्यान देने योग्य है, सब कुछ सरल और समझने योग्य डिज़ाइनों तक सीमित है:

 extension PersistentStorage { //   var foobar: KeyValueContainer<Int> { makeContainer() } } //   let foobar = storageInstance.foobar.value //   storageInstance.foobar.value = 123 

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

वह सब है। मुझे टिप्पणियों में प्रतिक्रिया देने में खुशी होगी। अलविदा!