स्विफ्ट कैप्चर लिस्ट: कमजोर, मजबूत और अज्ञात लिंक के बीच अंतर क्या है?

जोसेफ राइट, द प्रिजनर - इलस्ट्रेशन ऑफ ए स्ट्रांग कैप्चर

"कैप्चर किए गए" मूल्यों की सूची क्लोजर मापदंडों की सूची के सामने है और तीन अलग-अलग तरीकों से गुंजाइश से "कैप्चर" मूल्यों को जोड़ सकते हैं: लिंक का उपयोग करके "मजबूत", "कमजोर" या "अज्ञात"। हम अक्सर इसका इस्तेमाल करते हैं, मुख्य रूप से मजबूत संदर्भ चक्र ("मजबूत संदर्भ चक्र" उर्फ ​​"चक्र बरकरार") से बचने के लिए।
किसी नौसिखिया डेवलपर के लिए यह तय करना मुश्किल हो सकता है कि किस पद्धति का उपयोग करें, इसलिए आप "मजबूत" और "कमजोर" या "कमजोर" और "अज्ञात" के बीच चुनने में बहुत समय बिता सकते हैं, लेकिन समय के साथ, आपको एहसास होगा कि सही विकल्प - केवल एक।

सबसे पहले, एक साधारण वर्ग बनाएं:

class Singer { func playSong() { print("Shake it off!") } } 

फिर हम एक ऐसा फंक्शन लिखते हैं जो सिंगर क्लास का एक उदाहरण बनाता है और एक क्लोजर देता है जो सिंगर क्लास का प्लेसॉन्ग () विधि कहता है:

 func sing() -> () -> Void { let taylor = Singer() let singing = { taylor.playSong() return } return singing } 

अंत में, हम प्लेसॉन्ग का परिणाम प्राप्त करने के लिए कहीं भी गा सकते हैं ()

 let singFunction = sing() singFunction() 

नतीजतन, लाइन "इसे हिलाओ!" प्रदर्शित किया जाएगा।

मजबूत कब्जा

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

आइए एक बार फिर गायन () फ़ंक्शन पर नज़र डालें

 func sing() -> () -> Void { let taylor = Singer() let singing = { taylor.playSong() return } return singing } 

टेलर स्थिरांक को किसी फ़ंक्शन के अंदर परिभाषित किया जाता है, इसलिए सामान्य परिस्थितियों में जब फ़ंक्शन ने अपना काम समाप्त कर लिया है, तो उसकी जगह को मुक्त कर दिया जाएगा। हालांकि, इस स्थिरांक का उपयोग क्लोजर के अंदर किया जाता है, जिसका अर्थ है कि स्विफ्ट स्वचालित रूप से अपनी उपस्थिति सुनिश्चित करेगा जब तक कि फ़ंक्शन के अंत के बाद भी क्लोजर स्वयं मौजूद है।
यह कार्रवाई में एक "मजबूत" कब्जा है। यदि स्विफ्ट ने टेलर को मुक्त करने की अनुमति दी है, तो कॉलिंग बंद करना असुरक्षित होगा - इसकी taylor.playSong () विधि अब मान्य नहीं है।

"कमजोर" कब्जा (कमजोर कब्जा)

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

9. "कमजोर" कैप्चर किए गए मान क्लोजर द्वारा आयोजित नहीं किए जाते हैं और इस तरह उन्हें जारी किया जा सकता है और शून्य पर सेट किया जा सकता है।

2. पहले पैराग्राफ के परिणामस्वरूप, स्विफ्ट में "कमजोर रूप से पकड़े गए" मान हमेशा वैकल्पिक होते हैं।
हम "कमजोर" कैप्चर का उपयोग करके अपने उदाहरण को संशोधित करते हैं और तुरंत अंतर देखते हैं।

 func sing() -> () -> Void { let taylor = Singer() let singing = { [weak taylor] in taylor?.playSong() return } return singing } 

[कमजोर टेलर] - यह हमारी " कैप्चर लिस्ट " है, क्लोजर सिंटैक्स का एक विशेष भाग जिसमें हम निर्देश देते हैं कि मूल्यों को कैसे कैप्चर किया जाना चाहिए। यहां हम कहते हैं कि टेलर को "कमजोर रूप से" पकड़ा जाना चाहिए, इसलिए हमें टेलर का उपयोग करने की आवश्यकता है ।PlaySong () - अब यह वैकल्पिक है , क्योंकि इसे किसी भी समय शून्य पर सेट किया जा सकता है।

यदि आप अब इस कोड को निष्पादित करते हैं, तो आप देखेंगे कि कॉलिंग सिंगफंक्शन () अब संदेश में परिणाम नहीं देता है। इसका कारण यह है कि टेलर केवल सिंग () के अंदर ही मौजूद है, और इस फंक्शन के द्वारा बंद किया जाने वाला टेलर अपने अंदर "दृढ़ता से" टेलर को नहीं रखता है।

अब taylor बदलने का प्रयास करें ? .PlaySong () से taylor! (.PlaySong) () । यह बंद करने के लिए टेलर के जबरन अनपैकिंग को बढ़ावा देगा, और, तदनुसार, एक घातक त्रुटि ( शून्य से युक्त सामग्री को अनपैक करना)

"ओनरलेस" कैप्चर (अज्ञात कैप्चरिंग)

"कमजोर" कब्जा करने के लिए एक विकल्प "मालिक" है।

 func sing() -> () -> Void { let taylor = Singer() let singing = { [unowned taylor] in taylor.playSong() return } return singing } 

यह कोड असामान्य रूप से इसी तरह से समाप्त हो जाएगा जैसा कि ऊपर दिखाए गए वैकल्पिक रूप से तैनात वैकल्पिक के साथ है - प्रसिद्ध टेलर कहता है: "मुझे यकीन है कि क्लोजर की अवधि के लिए टेलर मौजूद होगा, इसलिए मुझे इसे स्मृति में रखने की आवश्यकता नहीं है।" वास्तव में, टेलर लगभग तुरंत जारी किया जाएगा और यह कोड क्रैश हो जाएगा।

इसलिए अनजाने उपयोग को बेहद सावधानी से करें।

आम समस्याएं

बंद करने में मूल्य कैप्चर का उपयोग करते समय डेवलपर्स को चार समस्याएं आती हैं:

1. बंद होने के मापदंडों के मामले में कैप्चर सूची के स्थान के साथ कठिनाइयाँ

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

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

 writeToLog { [weak self] user, message in self?.addToLog("\(user) triggered event: \(message)") } 

क्लोजर मापदंडों के बाद कैप्चर सूची डालने का प्रयास करने से संकलन त्रुटि हो जाएगी।

2. मजबूत लिंक के एक चक्र का उद्भव, एक स्मृति रिसाव के लिए अग्रणी

जब एक इकाई A की एक इकाई B होती है, और इसके विपरीत, आपके पास एक स्थिति होती है जिसे "चक्र बनाए रखना" कहा जाता है।

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

 class House { var ownerDetails: (() -> Void)? func printDetails() { print("This is a great house.") } deinit { print("I'm being demolished!") } } 

हमने हाउस क्लास को परिभाषित किया, जिसमें एक संपत्ति (क्लोजर), एक विधि, और एक डी-इनिशलाइज़र है जो एक संदेश प्रदर्शित करेगा जब कक्षा का एक उदाहरण नष्ट हो जाएगा।

अब पिछले एक के समान एक मालिक वर्ग बनाएं, सिवाय इसके कि उसकी बंद संपत्ति में घर के बारे में जानकारी शामिल है।

 class Owner { var houseDetails: (() -> Void)? func printDetails() { print("I own a house.") } deinit { print("I'm dying!") } } 

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

 print("Creating a house and an owner") do { let house = House() let owner = Owner() } print("Done") 

नतीजतन, संदेश प्रदर्शित किए जाएंगे: "एक घर और एक मालिक बनाना", "मैं मर रहा हूँ!", "मैं ध्वस्त हो गया हूँ!", फिर "पूर्ण" - सब कुछ उसी तरह काम करता है जैसे यह होना चाहिए।

अब मजबूत लिंक का एक लूप बनाएं।

 print("Creating a house and an owner") do { let house = House() let owner = Owner() house.ownerDetails = owner.printDetails owner.houseDetails = house.printDetails } print("Done") 

अब संदेश "एक घर और एक मालिक बनाने" दिखाई देगा, फिर "किया"। Deinitializers नहीं कहा जाएगा।

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

स्थिति को ठीक करने के लिए, हमें एक नया क्लोजर बनाने और एक या दो मामलों में "कमजोर" कैप्चर का उपयोग करने की आवश्यकता है, जैसे:

 print("Creating a house and an owner") do { let house = House() let owner = Owner() house.ownerDetails = { [weak owner] in owner?.printDetails() } owner.houseDetails = { [weak house] in house?.printDetails() } } print("Done") 

पकड़े गए दोनों मूल्यों को घोषित करने की आवश्यकता नहीं है, यह एक ही स्थान पर करने के लिए पर्याप्त है - यह स्विफ्ट को आवश्यक होने पर दोनों वर्गों को नष्ट करने की अनुमति देगा।

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

3. कई मूल्यों को कैप्चर करते समय, आमतौर पर मजबूत लिंक का अनजाने में उपयोग

स्विफ्ट डिफ़ॉल्ट रूप से एक मजबूत पकड़ का उपयोग करता है, जिससे अप्रत्याशित व्यवहार हो सकता है।
निम्नलिखित कोड पर विचार करें:

 func sing() -> () -> Void { let taylor = Singer() let adele = Singer() let singing = { [unowned taylor, adele] in taylor.playSong() adele.playSong() return } return singing } 

अब हमारे पास क्लोजर द्वारा पकड़े गए दो मूल्य हैं, और हम दोनों को उसी तरह से उपयोग करते हैं। हालाँकि, केवल टेलर को अज्ञात के रूप में कैप्चर किया गया है - एडेल को जोरदार तरीके से कैप्चर किया गया है, क्योंकि प्रत्येक कैप्चर किए गए मान के लिए अज्ञात कीवर्ड का उपयोग करना चाहिए।

यदि आपने उद्देश्य से ऐसा किया है, तो सब कुछ ठीक है, लेकिन यदि आप चाहते हैं कि दोनों मानों को " अज्ञात " पर कब्जा कर लिया जाए, तो आपको निम्नलिखित की आवश्यकता है:

 [unowned taylor, unowned adele] 

4. कॉपी क्लोजर और शेयर किए गए मूल्यों को साझा करें

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

 var numberOfLinesLogged = 0 let logger1 = { numberOfLinesLogged += 1 print("Lines logged: \(numberOfLinesLogged)") } logger1() 

यह संदेश "लाइन्स लॉग इन: 1" प्रदर्शित करेगा।
अब हम उस क्लोजर की एक कॉपी बनाएंगे, जो पहले बंद होने के साथ-साथ कैप्चर किए गए मानों को साझा करेगा। इस प्रकार, यदि हम मूल बंद या इसकी प्रतिलिपि कहते हैं, तो हम चर के बढ़ते मूल्य को देखेंगे।

 let logger2 = logger1 logger2() logger1() logger2() 

यह "लाइन्स लॉग इन: 1" ... "लाइन्स लॉग इन: 4" संदेशों को प्रिंट करेगा क्योंकि लॉगर 1 और लॉगर 2 एक ही कैप्चर किए गए नंबरऑनलाइनलॉग्ड वैरिएबल को इंगित करते हैं।

"मजबूत" कैप्चर, "कमजोर" और "ओनरलेस" का उपयोग कब करें

अब जब हम समझते हैं कि सब कुछ कैसे काम करता है, तो आइए संक्षेप में बताने की कोशिश करते हैं:

1. यदि आप सुनिश्चित हैं कि बंद किए जाने पर कैप्चर किया गया मान कभी भी शून्य नहीं होगा, तो आप "अज्ञात कैप्चरिंग" का उपयोग कर सकते हैं। यह एक असीम स्थिति है जहां "कमजोर" कैप्चर का उपयोग करते हुए अतिरिक्त कठिनाइयों का कारण हो सकता है, यहां तक ​​कि जब गार्ड का उपयोग बंद करने के अंदर एक कमजोर कब्जा मूल्य के लिए करते हैं।

2. यदि आपके पास एक मजबूत लिंक चक्र (निकाय A का मालिक B है, और निकाय B का स्वामित्व इकाई A है) का मामला है, तो उन मामलों में से एक में आपको "कमजोर कैप्चरिंग" का उपयोग करना होगा। यह ध्यान रखना आवश्यक है कि दोनों में से कौन सी संस्था पहले मुक्त हो जाएगी, इसलिए यदि दृश्य ए, व्यू कंट्रोलर बी का प्रतिनिधित्व करता है, तो व्यू कंट्रोलर बी में "ए" के लिए "कमजोर" लिंक शामिल हो सकता है।

3. यदि मजबूत लिंक के चक्र की संभावना को बाहर रखा गया है, तो आप "मजबूत" कैप्चर ( "मजबूत कैप्चरिंग" ) का उपयोग कर सकते हैं। उदाहरण के लिए, किसी एनीमेशन को निष्पादित करना एनीमेशन वाले क्लोजर के अंदर स्वयं को ब्लॉक नहीं करता है, इसलिए आप मजबूत बंधन का उपयोग कर सकते हैं।

4. यदि आप निश्चित नहीं हैं, तो एक "कमजोर" बंधन से शुरू करें और यदि आवश्यक हो तो इसे बदल दें।

वैकल्पिक - आधिकारिक स्विफ्ट गाइड:
शॉर्ट सर्किट
स्वचालित लिंक की गिनती