💇🏿 📮 💏 स्विफ्ट: एआरसी और मेमोरी मैनेजमेंट 🎭 🕷️ 🆚

आधुनिक उच्च-स्तरीय भाषा होने के नाते, स्विफ्ट मूल रूप से आपके अनुप्रयोगों में मेमोरी प्रबंधन का ध्यान रखती है, स्मृति को आवंटित और मुक्त करती है। यह एक तंत्र के कारण होता है जिसे ऑटोमैटिक रेफरेंस काउंटिंग या एआरसी कहा जाता है। इस गाइड में, आप सीखेंगे कि स्विफ्ट में ARC कैसे काम करता है और मेमोरी को ठीक से कैसे प्रबंधित करता है। इस तंत्र को समझते हुए, आप ढेर पर स्थित वस्तुओं के जीवनकाल को प्रभावित कर सकते हैं।

इस गाइड में, आप निम्नलिखित सीखकर स्विफ्ट और एआरसी के अपने ज्ञान का निर्माण करेंगे:

ARC कैसे काम करता है
संदर्भ चक्र क्या हैं और उन्हें सही तरीके से कैसे ठीक किया जाए
एक उदाहरण लिंक लूप कैसे बनाएं
Xcode द्वारा पेश किए गए विज़ुअल टूल का उपयोग करके लिंक लूप कैसे खोजें
संदर्भ प्रकारों और मान प्रकारों को कैसे संभालना है

शुरुआत हो रही है

स्रोत सामग्री डाउनलोड करें । चक्र / स्टार्टर फ़ोल्डर में प्रोजेक्ट खोलें। हमारे गाइड के पहले भाग में, मुख्य अवधारणाओं को समझते हुए, हम विशेष रूप से MainViewController.swif टी फ़ाइल से निपटेंगे ।

इस वर्ग को MainViewController.swift के नीचे जोड़ें:

class User { let name: String init(name: String) { self.name = name print("User \(name) was initialized") } deinit { print("Deallocating user named: \(name)") } }

उपयोगकर्ता वर्ग को यहाँ परिभाषित किया गया है, जो प्रिंट स्टेटमेंट की सहायता से, वर्ग उदाहरण के आरंभ और रिलीज़ के बारे में हमें संकेत देता है।

अब MainViewController के शीर्ष पर उपयोगकर्ता वर्ग का एक उदाहरण बनाएं।

इस कोड को viewDidLoad () विधि से पहले रखें:

 let user = User(name: "John")

ऐप लॉन्च करें। प्रिंट स्टेटमेंट का आउटपुट देखने के लिए कमांड-शिफ्ट-वाई के साथ दिखाई देने वाला Xcode कंसोल बनाएं।

ध्यान दें कि उपयोगकर्ता जॉन को इनिशियलाइज़ किया गया था कंसोल पर दिखाई दिया, लेकिन डिनिट के अंदर प्रिंट स्टेटमेंट निष्पादित नहीं किया गया था । इसका मतलब है कि यह ऑब्जेक्ट जारी नहीं किया गया था, क्योंकि यह दायरे से बाहर नहीं गया था।

दूसरे शब्दों में, जब तक इस ऑब्जेक्ट वाला व्यू कंट्रोलर दायरे से बाहर नहीं जाता, तब तक ऑब्जेक्ट को कभी भी फ्री नहीं किया जाएगा।

क्या वह दायरे में है?

एक विधि में उपयोगकर्ता वर्ग का एक उदाहरण लपेटकर, हम इसे दायरे से बाहर जाने देंगे, जिससे एआरसी इसे मुक्त कर सकेगी।

चलिए मेन व्यू कॉन्ट्रोलर क्लास के अंदर रनसेनारियो () विधि बनाते हैं और इसके अंदर यूजर क्लास इंस्टेंस के इनिशियलाइज़ेशन को आगे बढ़ाते हैं।

 func runScenario() { let user = User(name: "John") }

runScenario () उपयोगकर्ता उदाहरण के दायरे को परिभाषित करता है। इस क्षेत्र से बाहर निकलते समय, उपयोगकर्ता को मुक्त किया जाना चाहिए।

अब runScenario को कॉल करें (इसे viewDidLoad के अंत में जोड़कर) ():

 runScenario()

ऐप लॉन्च करें। कंसोल आउटपुट अब इस तरह दिखता है:

उपयोगकर्ता जॉन को आरंभीकृत किया गया
डीलक्लोकेटिंग उपयोगकर्ता नाम: जॉन

इसका मतलब है कि आपने एक ऑब्जेक्ट जारी किया है जो देखने के क्षेत्र को छोड़ दिया है।

वस्तु जीवन भर

वस्तु का अस्तित्व पाँच चरणों में विभाजित है:

स्मृति आवंटन: ढेर से या ढेर से
initialization: कोड को init के अंदर निष्पादित किया जाता है
का उपयोग
deinitialization: कोड को डीइनिट के अंदर निष्पादित किया जाता है
मुक्त मेमोरी: आवंटित मेमोरी स्टैक या हीप में वापस आ जाती है

स्मृति को आवंटित करने और मुक्त करने के चरणों को ट्रैक करने का कोई सीधा तरीका नहीं है, लेकिन आप इनिट और डिनिट के अंदर कोड का उपयोग कर सकते हैं।

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

जब उपयोगकर्ता ऑब्जेक्ट को इनिशियलाइज़ किया जाता है, तो उसकी संदर्भ संख्या 1 होती है, क्योंकि उपयोगकर्ता स्थिरांक इस ऑब्जेक्ट को संदर्भित करता है।

RunScenario () के अंत में, उपयोगकर्ता कार्यक्षेत्र से बाहर हो जाता है और संदर्भ संख्या 0. तक कम हो जाती है। परिणामस्वरूप, उपयोगकर्ता को अनइंस्टाल्यूट किया जाता है और फिर मुक्त किया जाता है।

संदर्भ चक्र

ज्यादातर मामलों में, एआरसी को काम करना चाहिए। डेवलपर को आमतौर पर मेमोरी लीक के बारे में चिंता करने की आवश्यकता नहीं होती है जब अप्रयुक्त ऑब्जेक्ट अनिश्चित काल तक बिना रुके रहते हैं।

लेकिन हमेशा नहीं! संभव स्मृति लीक।

यह कैसे हो सकता है? ऐसी स्थिति की कल्पना करें जहां दो वस्तुओं का उपयोग नहीं किया जाता है, लेकिन उनमें से प्रत्येक दूसरे को संदर्भित करता है। चूंकि प्रत्येक संदर्भ संख्या 0 नहीं है, उनमें से कोई भी मुक्त नहीं किया जाएगा।

यह एक मजबूत संदर्भ चक्र है । यह स्थिति एआरसी को भ्रमित करती है और इसे मेमोरी को साफ करने की अनुमति नहीं देती है।

जैसा कि आप देख सकते हैं, अंत में संदर्भ संख्या 0 नहीं है, और यद्यपि किसी भी ऑब्जेक्ट की अब आवश्यकता नहीं है, ऑब्जेक्ट 1 और ऑब्जेक्ट 2 को मुक्त नहीं किया जाएगा।

हमारे लिंक देखें

कार्रवाई में इस सब का परीक्षण करने के लिए, MainViewController.swift में उपयोगकर्ता वर्ग के बाद यह कोड जोड़ें:

 class Phone { let model: String var owner: User? init(model: String) { self.model = model print("Phone \(model) was initialized") } deinit { print("Deallocating phone named: \(model)") } }

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

अब इस लाइन को रनसेनारियो में जोड़ें ():

 let iPhone = Phone(model: "iPhone Xs")

यह फ़ोन वर्ग का एक उदाहरण बना देगा।

मोबाइल पकड़ो

अब इस कोड को उपयोगकर्ता वर्ग में जोड़ें, नाम संपत्ति के तुरंत बाद:

 private(set) var phones: [Phone] = [] func add(phone: Phone) { phones.append(phone) phone.owner = self }

उपयोगकर्ता के स्वामित्व वाले फ़ोन की एक सरणी जोड़ें। सेटर को निजी के रूप में चिह्नित किया जाता है, इसलिए ऐड (फोन :) का उपयोग किया जाना चाहिए।

ऐप लॉन्च करें। जैसा कि आप देख सकते हैं, फ़ोन और उपयोगकर्ता ऑब्जेक्ट वर्ग के उदाहरणों को आवश्यकतानुसार मुक्त किया गया है।

उपयोगकर्ता जॉन को आरंभीकृत किया गया
फ़ोन iPhone XS को प्रारंभ किया गया था
डीललोकास्टिंग फोन का नाम: iPhone Xs
डीलक्लोकेटिंग उपयोगकर्ता नाम: जॉन

अब इसे रनसेनारियो के अंत में जोड़ें ():

 user.add(phone: iPhone)

यहां हम अपने iPhone को उपयोगकर्ता के स्वामित्व वाले फ़ोन की सूची में जोड़ते हैं, और फ़ोन के स्वामी की संपत्ति को ' उपयोगकर्ता ' पर सेट करते हैं।

एप्लिकेशन को फिर से चलाएँ। आप देखेंगे कि उपयोगकर्ता और iPhone ऑब्जेक्ट रिलीज़ नहीं हुए हैं। उनके बीच मजबूत लिंक का चक्र एआरसी को जारी करने से रोकता है।

कड़ियाँ कमजोर

मजबूत लिंक के चक्र को तोड़ने के लिए, आप वस्तुओं के बीच संबंधों को कमजोर बना सकते हैं।

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

दूसरे शब्दों में, कमजोर लिंक किसी वस्तु के जीवन प्रबंधन को प्रभावित नहीं करते हैं । कमजोर लिंक को हमेशा वैकल्पिक घोषित किया जाता है। इस तरह, जब लिंक की संख्या 0 हो जाती है, तो लिंक को शून्य पर सेट किया जा सकता है।

इस चित्रण में, धराशायी रेखाएं कमजोर लिंक दर्शाती हैं। ध्यान दें कि object1 का संदर्भ गणना 1 है, क्योंकि वेरिएफ 1 इसका संदर्भ देता है। ऑब्जेक्ट 2 का संदर्भ गणना 2 है, क्योंकि यह वेरिएबल 2 और ऑब्जेक्ट 1 द्वारा संदर्भित है।

object2 भी object1 का संदर्भ देता है, लेकिन WEAK, जिसका अर्थ है कि यह object1 की संदर्भ संख्या को प्रभावित नहीं करता है।

जब variable1 और variable2 को मुक्त किया जाता है, तो object1 में 0 की संदर्भ संख्या होती है, जो इसे मुक्त करती है। यह बदले में, ऑब्जेक्ट 2 के लिए एक मजबूत संदर्भ जारी करता है, जो पहले से ही इसकी रिलीज की ओर जाता है।

फ़ोन वर्ग में, स्वामी की संपत्ति घोषणा को निम्नानुसार बदलें:

 weak var owner: User?

मालिक संपत्ति के संदर्भ को 'कमजोर' घोषित करके, हम उपयोगकर्ता और फोन कक्षाओं के बीच मजबूत लिंक के पाश को तोड़ते हैं।

ऐप लॉन्च करें। अब उपयोगकर्ता और फोन सही ढंग से जारी किए गए हैं।

प्रसिद्ध लिंक

एक और लिंक संशोधक भी है जो संदर्भ संख्या में वृद्धि नहीं करता है: अज्ञात ।

अनाम और कमजोर के बीच अंतर क्या है? एक कमजोर संदर्भ हमेशा वैकल्पिक होता है और संदर्भित ऑब्जेक्ट जारी होने पर स्वचालित रूप से शून्य हो जाता है।

यही कारण है कि हमें कमजोर गुणों को वैकल्पिक चर के रूप में घोषित करना चाहिए: इस संपत्ति को बदलना होगा।

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

आइए जाने अनजाने लागू करने का प्रयास करें।

MainViewController.swift के अंत में एक नया कैरियर सदस्यता वर्ग जोड़ें:

 class CarrierSubscription { let name: String let countryCode: String let number: String let user: User init(name: String, countryCode: String, number: String, user: User) { self.name = name self.countryCode = countryCode self.number = number self.user = user print("CarrierSubscription \(name) is initialized") } deinit { print("Deallocating CarrierSubscription named: \(name)") } }

कैरियरस्क्रिप्सन में चार गुण होते हैं:

नाम: प्रदाता का नाम।
देश कोड: देश कोड।
नंबर: फोन नंबर।
उपयोगकर्ता: उपयोगकर्ता के लिए लिंक।

आपका प्रदाता कौन है?

नाम संपत्ति के बाद अब इसे उपयोगकर्ता वर्ग में जोड़ें:

 var subscriptions: [CarrierSubscription] = []

यहां हम उपयोगकर्ता प्रदाताओं की एक सरणी रखते हैं।

अब मालिक की संपत्ति के बाद, इसे फ़ोन वर्ग में जोड़ें:

 var carrierSubscription: CarrierSubscription? func provision(carrierSubscription: CarrierSubscription) { self.carrierSubscription = carrierSubscription } func decommission() { carrierSubscription = nil }

यह प्रदाता के साथ फोन को पंजीकृत करने और अपंजीकृत करने के लिए वैकल्पिक कैरियर सदस्यता गुण और दो विधियाँ जोड़ता है।

अब प्रिंट स्टेटमेंट से ठीक पहले Init मेथड के अंदर CarrierSubscription क्लास जोड़ें:

 user.subscriptions.append(self)

हम उपयोगकर्ता प्रदाताओं की सरणी में CarrierSubscription जोड़ते हैं।

अंत में, रनसेनारियो () विधि के अंत में इसे जोड़ें:

 let subscription = CarrierSubscription( name: "TelBel", countryCode: "0032", number: "31415926", user: user) iPhone.provision(carrierSubscription: subscription)

हम उपयोगकर्ता के लिए प्रदाता के लिए एक सदस्यता बनाते हैं और फोन को उससे कनेक्ट करते हैं।

ऐप लॉन्च करें। कंसोल में आप देखेंगे:

उपयोगकर्ता जॉन को आरंभीकृत किया गया
फ़ोन iPhone Xs को प्रारंभ किया गया था
कैरियरबर्सक्रिप्शन टेलबेल को इनिशियलाइज़ किया गया है

और फिर से एक लिंक चक्र! उपयोगकर्ता, iPhone और सदस्यता अंत में मुक्त नहीं हुए।

क्या आपको कोई समस्या मिल सकती है?

श्रृंखला को तोड़ना

या तो उपयोगकर्ता से सदस्यता के लिए लिंक या सदस्यता से उपयोगकर्ता के लिए लिंक लूप को तोड़ने के लिए अज्ञात होना चाहिए। सवाल यह है कि कौन सा विकल्प चुनना है। आइए संरचनाओं को देखें।

एक उपयोगकर्ता एक प्रदाता के लिए एक सदस्यता का मालिक है, लेकिन इसके विपरीत - नहीं, एक प्रदाता की सदस्यता एक उपयोगकर्ता के पास नहीं है।

इसके अलावा, उपयोगकर्ता के संदर्भ के बिना CarrierSubscription के अस्तित्व का कोई मतलब नहीं है जो इसका मालिक है।

इसलिए, उपयोगकर्ता लिंक को अज्ञात होना चाहिए।

कैरियर घोषणा में उपयोगकर्ता घोषणा बदलें:

 unowned let user: User

अब उपयोगकर्ता अज्ञात है, जो लिंक के लूप को तोड़ देता है और आपको सभी वस्तुओं को मुक्त करने की अनुमति देता है।

क्लोजर में लूप लिंक

ऑब्जेक्ट के लिए लिंक चक्र तब होते हैं जब ऑब्जेक्ट में गुण होते हैं जो एक दूसरे को संदर्भित करते हैं। वस्तुओं की तरह, क्लोजर एक संदर्भ प्रकार है, और संदर्भ छोरों को जन्म दे सकता है। क्लोजर उन वस्तुओं को कैप्चर करते हैं जो वे उपयोग करते हैं।

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

उपयोगकर्ता संपत्ति के तुरंत बाद CarrierSubscription में यह कोड जोड़ें:

 lazy var completePhoneNumber: () -> String = { self.countryCode + " " + self.number }

यह क्लोजर पूर्ण टेलीफोन नंबर की गणना और रिटर्न करता है। संपत्ति को आलसी घोषित किया जाता है, इसे पहले उपयोग पर सौंपा जाएगा।

यह आवश्यक है क्योंकि यह self.countryCode और self.number का उपयोग करता है, जो कि शुरुआती कोड के निष्पादित होने तक उपलब्ध नहीं होगा।

RunScenario () को अंत में जोड़ें:

 print(subscription.completePhoneNumber())

कॉलिंग कम्प्लीट निष्पादित करेगा।

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

सूची पर कब्जा

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

कैप्चर सूची प्रदर्शित करने के लिए, निम्नलिखित कोड पर विचार करें:

 var x = 5 var y = 5 let someClosure = { [x] in print("\(x), \(y)") } x = 6 y = 6 someClosure() // Prints 5, 6 print("\(x), \(y)") // Prints 6, 6

x क्लोजर कैप्चर सूची में है, इसलिए x का मान क्लोजर परिभाषा में कॉपी किया गया है। यह मूल्य द्वारा कब्जा कर लिया है।

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

लॉक सूचियाँ लूप के भीतर कैप्चर की गई वस्तुओं के संबंध में कमजोर या अज्ञात बातचीत को पहचानने में मदद करती हैं। हमारे मामले में, उपयुक्त विकल्प अज्ञात है, क्योंकि वाहक बंद होने के उदाहरण जारी होने के बाद एक बंद नहीं हो सकता है।

अपने आप को जब्त

वाहक की सदस्यता के साथ FullPhoneNumber परिभाषा बदलें:

 lazy var completePhoneNumber: () -> String = { [unowned self] in return self.countryCode + " " + self.number }

हम क्लोज़र कैप्चर सूची में [प्रसिद्ध स्वयं] जोड़ते हैं। इसका मतलब यह है कि हमने एक मजबूत के बजाय एक अज्ञात लिंक के रूप में स्वयं को पकड़ लिया।

एप्लिकेशन लॉन्च करें और आप देखेंगे कि कैरियरसर्क्रिप्शन अब जारी किया गया है।

वास्तव में, उपरोक्त वाक्यविन्यास एक लंबे और अधिक पूर्ण का संक्षिप्त रूप है जिसमें एक नया चर दिखाई देता है:

 var closure = { [unowned newID = self] in // Use unowned newID here... }

यहाँ newID स्वयं की एक अज्ञात प्रति है। बंद से परे, स्वयं ही रहता है। पहले दिए गए संक्षिप्त रूप में, हम एक नया सेल्फ वेरिएबल बनाते हैं जो क्लोजर के अंदर मौजूद सेल्फ को अस्पष्ट करता है।

ध्यान से उपयोग न करें

आपके कोड में, स्वयं और पूर्ण फ़ोनफोन के बीच संबंध को अज्ञात के रूप में निर्दिष्ट किया गया है।

यदि आप सुनिश्चित हैं कि क्लोजर में उपयोग की गई वस्तु को जारी नहीं किया जाएगा, तो आप अज्ञात का उपयोग कर सकते हैं। अगर वह करता है, तो आप मुसीबत में हैं!

इस कोड को MainViewController.swift के अंत में जोड़ें:

 class WWDCGreeting { let who: String init(who: String) { self.who = who } lazy var greetingMaker: () -> String = { [unowned self] in return "Hello \(self.who)." } }

अब यहाँ रनसेनारियो का अंत है ():

 let greetingMaker: () -> String do { let mermaid = WWDCGreeting(who: "caffeinated mermaid") greetingMaker = mermaid.greetingMaker } print(greetingMaker()) // !

एप्लिकेशन लॉन्च करें और आपको कंसोल में क्रैश और ऐसा कुछ दिखाई देगा:

उपयोगकर्ता जॉन को आरंभीकृत किया गया
फ़ोन iPhone XS को प्रारंभ किया गया था
कैरियरबर्सक्रिप्शन टेलबेल इनिशियलाइज़्ड है
0032 31415926
घातक त्रुटि: एक अज्ञात संदर्भ को पढ़ने का प्रयास किया गया है, लेकिन ऑब्जेक्ट 0x600000f0de30 पहले से ही डील किया गया था2019-02-24 12: 29: 40.744248-0600 चक्र [33489: 5926466: घातक त्रुटि: एक अज्ञात संदर्भ को पढ़ने का प्रयास किया गया था, लेकिन ऑब्जेक्ट 0x600000f0de30 पहले से ही अस्वीकृत था।

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

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

जाल को नकारना

इसके साथ WWDCGreeting वर्ग में ग्रीटिंगमेकर को बदलें:

 lazy var greetingMaker: () -> String = { [weak self] in return "Hello \(self?.who)." }

हमने दो काम किए: पहला, हमने अनजाने को कमजोर से बदल दिया। दूसरे, चूंकि स्वयं कमजोर हो गया है, हम स्वयं के माध्यम से संपत्ति का उपयोग करते हैं? Xcode की चेतावनी को अनदेखा करें, हम इसे जल्द ही ठीक कर देंगे।

एप्लिकेशन अब क्रैश नहीं होता है, लेकिन यदि आप इसे चलाते हैं, तो हमें एक मजेदार परिणाम मिलता है: "हेलो नील।"

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

इसके साथ क्लोजर टेक्स्ट को बदलें:

 lazy var greetingMaker: () -> String = { [weak self] in guard let self = self else { return "No greeting available." } return "Hello \(self.who)." }

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

Xcode 10 में लिंक लूप की तलाश है

अब जब आप समझते हैं कि एआरसी कैसे काम करता है, लिंक लूप क्या हैं और उन्हें कैसे तोड़ना है, यह एक वास्तविक एप्लिकेशन का उदाहरण देखने का समय है।

संपर्क फ़ोल्डर में स्थित स्टार्टर प्रोजेक्ट खोलें।

ऐप लॉन्च करें।

यह सबसे सरल संपर्क प्रबंधक है। संपर्क पर क्लिक करने का प्रयास करें, कुछ नए जोड़े।

फ़ाइल असाइनमेंट:

ContactsTableViewController: सभी संपर्कों को दिखाता है।
DetailViewController: चयनित संपर्क की विस्तृत जानकारी दिखाता है।
NewContactViewController: आपको एक नया संपर्क जोड़ने की अनुमति देता है।
ContactTableViewCell: संपर्क विवरण दिखाने वाली तालिका सेल।
संपर्क: संपर्क मॉडल।
नंबर: फोन नंबर मॉडल।

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

सौभाग्य से, Xcode 10 में सबसे छोटे मेमोरी लीक को खोजने के लिए अंतर्निहित टूल हैं।

एप्लिकेशन को फिर से लॉन्च करें। बाईं ओर स्वाइप और डिलीट बटन का उपयोग करके 3-4 संपर्क हटाएं। ऐसा लगता है जैसे वे पूरी तरह से गायब हो जाते हैं, है ना?

यह कहां बहता है?

जब अनुप्रयोग चल रहा हो, तो डिबग मेमोरी ग्राफ़ बटन पर क्लिक करें:

डिबग नाविक में रनटाइम मुद्दों का निरीक्षण करें। वे बैंगनी वर्गों के साथ एक सफेद विस्मयादिबोधक चिह्न के साथ चिह्नित हैं:

नाविक में समस्याग्रस्त संपर्क वस्तुओं में से एक का चयन करें। चक्र स्पष्ट रूप से दिखाई देता है: संपर्क और संख्या ऑब्जेक्ट, एक दूसरे का जिक्र करते हुए, पकड़।

लगता है कि आपको कोड में देखना चाहिए। ध्यान रखें कि एक संपर्क एक संख्या के बिना मौजूद हो सकता है, लेकिन इसके विपरीत नहीं।

आप इस लूप को कैसे हल करेंगे? संपर्क से नंबर से लिंक या नंबर से संपर्क? कमजोर या नामी? पहले इसे स्वयं आज़माएं!

यदि आपको सहायता की आवश्यकता हो ...

2 संभावित समाधान हैं: या तो संपर्क से नंबर को कमजोर करने के लिए एक लिंक बनाएं, या नंबर से संपर्क से अज्ञात।

Apple के प्रलेखन की सलाह है कि मूल वस्तु का "बच्चे" का एक मजबूत संदर्भ है - इसके विपरीत नहीं। इसका अर्थ है कि हम संपर्क को संख्या और संख्या के लिए एक मजबूत संदर्भ देते हैं - संपर्क करने के लिए एक अज्ञात लिंक:

 class Number { unowned var contact: Contact // Other code... } class Contact { var number: Number? // Other code... }

बोनस: संदर्भ प्रकार और मूल्य प्रकार के साथ छोरों।

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

इसका मतलब है कि मूल्य प्रकारों के मामले में, कोई चक्र नहीं हो सकता है। लूप होने के लिए, हमें कम से कम 2 संदर्भ प्रकार चाहिए।

आइए साइकिल परियोजना पर वापस जाएं और MainViewController.swift के अंत में यह कोड जोड़ें:

 struct Node { // Error var payload = 0 var next: Node? }

काम नहीं करेगा! संरचना एक मूल्य प्रकार है और स्वयं के उदाहरण पर पुनरावृत्ति नहीं हो सकती है। अन्यथा, ऐसी संरचना में अनंत आकार होगा।

संरचना को कक्षा में बदलें।

 class Node { var payload = 0 var next: Node? }

कक्षाओं (संदर्भ प्रकार) के लिए स्वयं का संदर्भ काफी स्वीकार्य है, इसलिए कंपाइलर को समस्याएं नहीं होती हैं।

अब इसे MainViewController.swift के अंत में जोड़ें:

 class Person { var name: String var friends: [Person] = [] init(name: String) { self.name = name print("New person instance: \(name)") } deinit { print("Person instance \(name) is being deallocated") } }

और यह रनसेनारियो के अंत में है ():

 do { let ernie = Person(name: "Ernie") let bert = Person(name: "Bert") ernie.friends.append(bert) // Not deallocated bert.friends.append(ernie) // Not deallocated }

ऐप लॉन्च करें। कृपया ध्यान दें: न तो ernie और न ही बर्ट जारी किए जाते हैं।

लिंक और अर्थ

यह एक संदर्भ प्रकार और एक मूल्य प्रकार के संयोजन का एक उदाहरण है जिसने लिंक के एक लूप को जन्म दिया है।

इरेनी और बर्ट अप्रतिबंधित रहते हैं, एक दूसरे को अपने दोस्तों के सरणियों में पकड़ते हैं, हालांकि एरे स्वयं मूल्य प्रकार हैं।

दोस्तों के संग्रह को अज्ञात बनाने की कोशिश करें, और Xcode एक त्रुटि दिखाएगा: अमान्य केवल कक्षाओं में लागू होता है।

इस लूप को ठीक करने के लिए, हमें एक आवरण ऑब्जेक्ट बनाना होगा और इसका उपयोग सरणी में उदाहरण जोड़ने के लिए करना होगा।

व्यक्ति वर्ग से पहले निम्नलिखित परिभाषा जोड़ें:

 class Unowned<T: AnyObject> { unowned var value: T init (_ value: T) { self.value = value } }

फिर व्यक्ति वर्ग में दोस्तों की परिभाषा बदलें:

 var friends: [Unowned<Person>] = []

अंत में, रनसेनारियो () में करो ब्लॉक की सामग्री को प्रतिस्थापित करें:

 do { let ernie = Person(name: "Ernie") let bert = Person(name: "Bert") ernie.friends.append(Unowned(bert)) bert.friends.append(Unowned(ernie)) }

एप्लिकेशन लॉन्च करें, अब ernie और बर्ट सही ढंग से जारी किए गए हैं!

मित्र सरणी अब व्यक्तिगत वस्तुओं का संग्रह नहीं है। यह अब प्रसिद्ध वस्तुओं का एक संग्रह है जो व्यक्तिगत उदाहरणों के लिए रैपर के रूप में काम करता है।

व्यक्ति से व्यक्तिगत वस्तुएं प्राप्त करने के लिए, मूल्य संपत्ति का उपयोग करें:

 let firstFriend = bert.friends.first?.value // get ernie

निष्कर्ष

अब आपको स्विफ्ट में मेमोरी प्रबंधन की अच्छी समझ है और आप जानते हैं कि एआरसी कैसे काम करता है। मुझे आशा है कि प्रकाशन आपके लिए उपयोगी था।

Apple: ऑटोमैटिक रेफरेंस काउंटिंग

स्विफ्ट: एआरसी और मेमोरी मैनेजमेंट