Swift-style-guide: आलसी आरंभिक पैटर्न

बीटीडब्ल्यू, क्या स्वयं चक्रीय रूप से यहां रखा गया है? मुझे लगता है कि [unowned self] या [weak self] जोड़ा जाना चाहिए

एक प्रश्न भी है:
इस मामले में मजबूत स्वयं के लिए अनुशंसित नाम क्या है, यह आपके गाइड में नहीं मिला है:

if let strongSelf = self {

}

मुझे नहीं लगता कि यह मायने रखता है कि स्वयं को बरकरार रखा गया है या नहीं, क्योंकि जब भी locationManager चर का उपयोग किया जाता है और फिर नष्ट हो जाता है तो बंद हो जाता है।

हालांकि मैं पूरी तरह से निश्चित नहीं हूं कि क्या होता है जब आप कभी भी locationManager पर कॉल नहीं करते हैं। उस स्थिति में, बंद वास्तव में स्वयं को पकड़ कर रख सकता है। दिलचस्प। :-)

संपादित करें: बस इसका परीक्षण किया और इस बंद में स्वयं का उपयोग करना ठीक लगता है। मुझे लगता है कि जब तक आप पहली बार locationManager पर कॉल नहीं करते हैं, तब तक क्लोजर वास्तव में नहीं बनता है। और फिर यह तुरंत समाप्त हो जाता है और फिर से नष्ट हो जाता है।

वैसे, ! की आवश्यकता नहीं है; यह ठीक काम करता है:

lazy var locationManager: CLLocationManager = {

धन्यवाद, मैंने ! को हटाने के लिए मूल कोड ब्लॉक को अपडेट किया है। लेकिन हमें अभी भी मुख्य प्रश्न पर चर्चा करने की आवश्यकता है - क्या हमें इस पैटर्न को अपने स्टाइल गाइड में प्रोत्साहित करना चाहिए या नहीं?

मुझे यह पसंद है। यह चीज़ के इनिशियलाइज़ेशन को चीज़ की घोषणा के करीब रखता है। नतीजतन, viewDidLoad() छोटा और पढ़ने में आसान हो जाता है।

मुझे भी पसंद है। मैं

यदि एक मजबूत संदर्भ चक्र के साथ समस्याएं हैं तो [unowned self] इसे ठीक करना चाहिए मुझे लगता है:

lazy var locationManager: CLLocationManager = {
  [unowned self] in
  let manager = CLLocationManager()
  manager.delegate = self
  ...
  return manager
}()

मुझे यह दृष्टिकोण पसंद है, लेकिन मैं आपत्तियों को देखने के लिए संघर्ष कर रहा हूं। क्या यह सिर्फ इतना है कि यह दृष्टिकोण कुछ हद तक स्पष्ट नहीं है, और इसमें सूक्ष्म बारीकियां हो सकती हैं (जैसे मजबूत बनाए रखने वाले चक्रों की संभावना)?

(संदर्भ: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html#//apple_ref/doc/uid/TP40014097-CH20-ID57)

आईएमओ यह सिर्फ एक पैटर्न है। शायद यह एक स्विफ्ट-पैटर्न रेपो में है। चक्र बनाए रखने के लिए, मुझे यह याद आ रहा है। यह सिर्फ एक सामान्य प्रतिनिधि असाइनमेंट है। यदि आपने अभी-अभी CLLocationManager इनिशियलाइज़ेशन स्टफ को इनिशियलाइज़ेशन मेथड में किया है, तो इसका अलग-अलग व्यवहार क्यों किया जाना चाहिए? प्रतिनिधि पैटर्न आम तौर पर प्रतिनिधि संपत्ति (इस मामले में, CLLocationManager के भीतर) को कमजोर के रूप में परिभाषित करने के लिए प्रोत्साहित करता है, नहीं?

मेरी गलती फिर से मजबूत चक्र बनाए रखती है। यह कोई समस्या नहीं है क्योंकि बंद निष्पादित किया गया है। अगर यह बंद कर रहा था तो [unowned self] का उपयोग करना आवश्यक हो सकता है, हालांकि इस मामले में नहीं क्योंकि इसे कमजोर रूप से आयोजित प्रतिनिधि के रूप में सौंपा जा रहा है।

यह भी ध्यान देने योग्य है कि आलसी संस्करण उत्पन्न करने के लिए निर्दिष्ट बंद वर्ग के किसी भी परिवर्तनशील गुणों पर निर्भर नहीं होना चाहिए। इस बिंदु पर कि आलसी संस्करण उत्पन्न होता है (बंद होने के मूल्यांकन के माध्यम से) यह इन निर्भरताओं के वर्तमान मूल्यों को पकड़ लेगा। यदि var नहीं बदलता है तो यह भ्रमित करने वाला होगा।

इस उदाहरण को http://mikebuss.com/2014/06/22/lazy-initialization-swift/ से देखें

class Person {
    var name: String

    lazy var personalizedGreeting: String = {
        [unowned self] in
        return "Hello, \(self.name)!"
        }()

    init(name: String) {
        self.name = name
    }
}

मुझे लगता है कि यह भ्रमित करने वाला है:

let p = Person(name: "sam")
p.personalizedGreeting
// => "Hello, sam!"

p.name = "definitely somebody else"
p.personalizedGreeting
// => "Hello, sam!"

इस सारी हलचल के बाद, मुझे अभी भी लगता है कि यह एक अच्छा पैटर्न है, और ट्यूटोरियल में उपयोग के लिए उपयुक्त है, लेकिन यह महत्वपूर्ण है कि लेखक इन मुद्दों को समझें ताकि ये अपेक्षाकृत जटिल गलतियाँ न हों।

/ मैं अब चुप हो जाऊंगा

Apple डॉक्स में जो @sammyd लिंक करता है, Apple वास्तव में इसे एक उदाहरण के रूप में देता है:

lazy var asHTML: () -> String = {
    [unowned self] in
    if let text = self.text {
        return "<\(self.name)>\(text)</\(self.name)>"
    } else {
        return "<\(self.name) />"
    }
}

दूसरे लिंक में @sammyd देता है (वह लिंक आज खुश है:]), लेखक इसे एक उदाहरण के रूप में देता है:

lazy var personalizedGreeting: String = {
        [unowned self] in
        return "Hello, \(self.name)!"
        }()

मुझे नहीं लगता कि इन मामलों में unowned self का उपयोग करना कभी भी एक समस्या होगी ... यानी, आलसी गुण बनाने में ... मैं कुछ मामलों में कल्पना करता हूं, हालांकि (जैसा कि @sammyd फिर से उल्लेख करता है, एक लौट रहा है ब्लॉक, शायद अन्य?) _not_ unowned का उपयोग करना समस्याग्रस्त हो सकता है।

सादगी के लिए, आलसी गुणों के लिए हमेशा unowned का उपयोग क्यों न करें?

भले ही, मैं इस पैटर्न का उपयोग करने के लिए तैयार हूं। :+1:

ध्यान दें कि asHTML चर _stores_ बाद में उपयोग के लिए बंद। हम यहां जिस चीज के बारे में बात कर रहे हैं, वह एक क्लोजर का उपयोग करके एक रेगुलर वेरिएबल को इनिशियलाइज़ कर रही है जिसे तुरंत निष्पादित किया जाता है।

मुझे यह lazy और गैर- lazy दोनों संपत्तियों के लिए पसंद है।

मुझे यकीन नहीं है कि इस गाइड में मार्गदर्शन क्या होगा। _हमेशा_ ऐसा ही करते हैं? यदि आपके पास कुछ परिकलित स्थिरांक या रंग थे, तो मैं "पुराने तरीके" का लाभ भी देख सकता हूं, जो वस्तुओं का पुन: उपयोग करने के लिए viewDidLoad() में कई चीजों को आरंभ करता है। यह मेरे लिए मामला-दर-मामला जैसा लगता है।

मैंने uilabels/textviews/के सबव्यू के साथ वर्षों से ui विचारों को तुरंत चालू करने के लिए initWithFrame कॉल का उपयोग किया है और यह कोड को सरल बनाता है और जीवन चक्र कॉल को देखने पर ट्रिपिंग से बचाता है - खासकर सुपर क्लास को कॉल करते समय।
क्या यह एक छोटे से प्रदर्शन को प्रभावित करता है? शायद। क्या यह uikit के प्रवाह और निब फ़ाइलों का उपयोग करने के विरुद्ध जाता है? हां। क्या मैं निब फाइलों के समस्या निवारण में घंटों बिताता हूं? नहीं। क्या मेरे ऐप्स समय पर शिप होते हैं? हां। क्या मैं चिंतित हूँ? नहीं। क्या अन्य डेवलपर हैरान हैं? शायद। क्या मुझे परवाह है - नहीं।
सरल कोड = सरल तर्क - बनाए रखने में आसान।

कुछ लोग तर्क देंगे कि प्रदर्शन या स्मृति के लिए जब तक दृश्य नियंत्रक प्रस्तुत नहीं किया जाता है (इसे नेविगेशन नियंत्रक पर धक्का दिया गया था) - फिर नियंत्रणों को तुरंत चालू न करें (viewDidLoad / loadView की प्रतीक्षा करें)। इससे पहले कि हम स्वयं दृश्य नियंत्रकों पर आलसी युद्धों तक पहुँच प्राप्त करते थे।
तो यह पूर्व-खाली तात्कालिकता की उस समस्या को हल करता है।

उदाहरण के लिए
आलसी वर लॉगिनवीसी = {वापसी लॉगिनवीसी ()} ()

नोट - मैंने यहां init विधि को ओवरराइड किया है - (कोई xib फाइल नहीं)

required public init() {
    super.init(nibName: nil, bundle: nil)
}

स्टैक ओवरफ्लो से
http://stackoverflow.com/questions/27585409/use-a-programmatically-created-uitableviewcell-subclass-in-swift/31801507#31801507

इस

क्लास इवेंटसेल: UITableViewCell {

var eventName: UILabel = UILabel()
var eventCity: UILabel = UILabel()
var eventTime: UILabel = UILabel()

override init(style: UITableViewCellStyle, reuseIdentifier: String?) {
    super.init(style: style, reuseIdentifier: reuseIdentifier)

    self.contentView.addSubview(eventName)
    self.contentView.addSubview(eventCity)
    self.contentView.addSubview(eventTime)
}

override func layoutSubviews() {
    super.layoutSubviews()

    eventName = UILabel(frame: CGRectMake(20, 10, self.bounds.size.width - 40, 25))
    eventCity = UILabel(frame: CGRectMake(0, 0, 0, 0))
    eventTime = UILabel(frame: CGRectMake(0, 0, 0, 0))

}

}

बनाम

class EventCell: UITableViewCell {
   lazy public  var lblName = {
    return UILabel (frame: CGRectMake(10, 0, self.bounds.size.width , 40))
  }()

  lazy public  var lblCity = {
   return UILabel (frame: CGRectMake(10, 40, self.bounds.size.width , 20))
  }()
 lazy public  var lblTime = {
      return UILabel (frame: CGRectMake(self.bounds.size.width - 80, 10, , 25))
   }()


   override init(style: UITableViewCellStyle, reuseIdentifier: String?) {
   super.init(style: style, reuseIdentifier: reuseIdentifier)

    self.contentView.addSubview(lblName)
    self.contentView.addSubview(lblCity)
    self.contentView.addSubview(lblTime)
 }

}  

लगभग [unowned self] को बनाए रखने के चक्र को रोकने के लिए उपयोग किया जाता है: अब ऐसा नहीं है।

Apple द्वारा दिया गया और ऊपर @sammyd द्वारा लिंक किया गया नमूना कोड अब [unowned self] का उपयोग नहीं करता है:

lazy var asHTML: Void -> String = {
    if let text = self.text {
        return "<\(self.name)>\(text)</\(self.name)>"
    } else {
        return "<\(self.name) />"
    }
}

और वास्तव में मैं एक नग्न self को संदर्भित करने वाले बंद होने के साथ शुरू किए गए आलसी संस्करण का उपयोग करके कभी भी एक deinit को याद नहीं कर सकता था।

अब मुझे नहीं पता कि उन क्लोजर में self परोक्ष रूप से unowned या unowned(unsafe) है या नहीं। फिर भी हमें इसे स्पष्ट करना बंद कर देना चाहिए, क्योंकि यह निहित है।

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

एरिक चेम्बरलेन, लीड आर्किटेक्ट - आईओएस
आर्कटच - ऐप डेवलपमेंट स्टूडियो

एरिक चेंबरलेन @arctouch.com mailto:[email protected]
+1-415-944-2000

विश्व स्तरीय ब्रांडों और फॉर्च्यून 500 . के लिए कस्टम ऐप्स
arctouch.com/work | आर्कटच.कॉम/ब्लॉग

8 दिसंबर 2015 को सुबह 8:18 बजे, ग्वेन्डल रूए नोटिफ़िकेशन @github.com ने लिखा:

[अज्ञात स्व] के बारे में चक्र को बनाए रखने से रोकने के लिए उपयोग किया जाता है: अब ऐसा नहीं है।

नमूना कोड https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html#//apple_ref/doc/uid/TP40014097 -CH20-ID57 Apple द्वारा दिया गया और ऊपर लिंक किया गया @sammyd द्वारा https://github.com/sammyd अब [अज्ञात स्वयं] का उपयोग नहीं करता है:

आलसी संस्करण HTML: शून्य -> ​​स्ट्रिंग = {
अगर पाठ दें = स्वयं पाठ {
वापसी "<(स्वयं का नाम)> (पाठ) (स्वयं नाम)>"
} अन्यथा {
वापसी "<(स्वयं का नाम) />"
}
}
और वास्तव में मैं एक नग्न स्व का संदर्भ देने वाले बंद होने के साथ शुरू किए गए आलसी संस्करण का उपयोग करके कभी भी एक deinit को याद नहीं कर सकता था।

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

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub https://github.com/raywenderlich/swift-style-guide/issues/88#issuecomment -162933300 पर देखें।

@ arctouch-ericchamberlain, आप सही कह रहे हैं, नमूना कोड अब संपत्ति में बंद हो जाता है।

फिर भी, मैं अपने आप को दोहराता हूं, "मैं कभी भी एक आलसी संस्करण का उपयोग करके एक डिनिट को याद नहीं कर सकता था जो एक नग्न आत्म को संदर्भित करता है।"

उदाहरण के तौर पर:

class C {
    lazy var d: String = { "\(self)" }()
    deinit { print("deinit") }
}

C()   // deinit
C().d // deinit

आप इसे स्वयं आजमा सकते हैं। अगर आपको एक रिटेन साइकल मिलती है, तो मुझे फिर से [unowned self] का उपयोग करने में खुशी होगी।

ऐसा है क्योंकि

आलसी वर कुछ = {..}()

कुछ भी नहीं रखता है। जब वेरिएबल को इनिशियलाइज़ किया जाता है तो क्लोजर का निर्माण और निष्पादन किया जाता है। जबकि,

आलसी वर कुछ = {…}

चर प्रारंभ होने पर एक मजबूत संदर्भ चक्र बनाता है।

नमूना कोड में asHTML चर बाद के मामले में आता है।

अपने प्रारंभकर्ता से () निकालें, फिर देखें कि क्या होता है।

एरिक चेम्बरलेन, लीड आर्किटेक्ट - आईओएस
आर्कटच - ऐप डेवलपमेंट स्टूडियो

एरिक चेंबरलेन @arctouch.com mailto:[email protected]
+1-415-944-2000

विश्व स्तरीय ब्रांडों और फॉर्च्यून 500 . के लिए कस्टम ऐप्स
arctouch.com/work | आर्कटच.कॉम/ब्लॉग

9 दिसंबर 2015 को दोपहर 2:10 बजे, ग्वेन्डल रूए नोटिफिकेशन @github.com ने लिखा:

@ arctouch-ericchamberlain https://github.com/arctouch-ericchamberlain , आप सही कह रहे हैं, नमूना कोड अब संपत्ति में एक क्लोजर स्टोर करता है।

फिर भी, मैं अपने आप को दोहराता हूं, "मैं कभी भी एक आलसी संस्करण का उपयोग करके एक डिनिट को याद नहीं कर सकता था जो एक नग्न आत्म को संदर्भित करता है।"

उदाहरण के तौर पर:

कक्षा सी {
आलसी संस्करण डी: स्ट्रिंग = {"(स्वयं)"}()
दीनिट {प्रिंट ("डीनिट")}
}

सी () // deinit
सी ()। डी // deinit
आप इसे स्वयं आजमा सकते हैं। अगर आपको एक रिटेन साइकल मिलती है, तो मुझे [अज्ञात स्व] का फिर से उपयोग करने में खुशी होगी।

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub https://github.com/raywenderlich/swift-style-guide/issues/88#issuecomment -163413290 पर देखें।

मैं आपका अनुसरण नहीं करता।

उन आलसी युद्धों में से किसी को भी [unowned self] की आवश्यकता नहीं है:

lazy var d: String = { "\(self)" }()
lazy var asHTML: Void -> String = { "\(self)" }

किस तरह का आलसी संस्करण करता है?

ओह, HTML के रूप में कॉल करना वास्तव में बनाए रखने का चक्र बनाता है।

धन्यवाद @ arctouch-ericchamberlain। मुझसे गलती हुई है।

@groue

ऐप्पल दस्तावेज़ [unowned self] का उपयोग नहीं करने का कारण यह है कि वे उस स्थिति को स्थापित कर रहे हैं जहां कोई समस्या है:

दुर्भाग्य से, HTMLElement वर्ग, जैसा कि ऊपर लिखा गया है, HTMLElement उदाहरण और इसके डिफ़ॉल्ट asHTML मान के लिए उपयोग किए जाने वाले क्लोजर के बीच एक मजबूत संदर्भ चक्र बनाता है।

इसके बाद वे [unowned self] के अतिरिक्त इसे ठीक करने के लिए आगे बढ़ते हैं:

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

जिसके परिणामस्वरूप यह कार्यान्वयन होता है:

lazy var asHTML: Void -> String = {
    [unowned self] in
    if let text = self.text {
        return "<\(self.name)>\(text)</\(self.name)>"
    } else {
        return "<\(self.name) />"
    }
}

उस दस्तावेज़ीकरण पृष्ठ का एक अच्छा विवरण है कि कब चक्र बनाए रखना संभव है और आपको इससे बाहर निकलने के लिए unowned या weak का उपयोग कब करना चाहिए।

@ जॉन्डपोप

इस कार्यान्वयन के साथ तुलना करने का प्रयास करें, सुनिश्चित नहीं है कि मैंने क्या याद किया है लेकिन ऐप्पल से मैंने जो नमूने देखे हैं, वे सामान सेट करने के लिए क्लोजर ब्रैकेट से बचते हैं।

class EventCell: UITableViewCell {

    lazy public var lblName = UILabel(frame: CGRectZero)
    lazy public var lblCity = UILabel(frame: CGRect())
    lazy public var lblTime = UILabel(frame: CGRect(x: 0, y: 0, width: 0, height: 0))

} 

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

आप आलसी का उपयोग कर रहे हैं क्योंकि आपके पास कुछ भारी है जिसे निष्पादित नहीं किया जा सकता है इसलिए इसकी आवश्यकता नहीं है या आप इसके निष्पादन में देरी करना चाहते हैं जो संयोग से उपयोगकर्ता को निरस्त करने की अनुमति देता है।

तो संभावना है कि, उक्त वर्ग के आपके स्वामित्व के बाद, एक रिसाव पैदा करने के बाद क्लोजर स्वयं को बनाए रखेगा।
हमेशा कमजोर/अज्ञात का उपयोग करें, भले ही आप 100% सुनिश्चित हों कि बंद होने का आह्वान किया जाएगा।
आखिरकार, मुझे संदेह है कि संकलक इसे संभाल लेगा। बंद होने वाली आलसी संपत्ति को केवल एक बार निष्पादित किया जा सकता है, dispatch_once(..) सोचें। वैसे भी, मैं शायद इसी तरह रोल करूँगा।

सबसे पहले, स्मृति संदर्भ चीज़ को रास्ते से हटा दें। (यहां तक ​​​​कि आलसी पर शीर्ष हिट ब्लॉग पोस्ट भी गलत हो जाते हैं। हमें उस मैक्सिम को बदलने की जरूरत है!) ऊपर वर्णित कारणों से, यह लीक नहीं होता है। वह है: बंद को एक बार आलसी रूप से निष्पादित किया जाता है। यदि इसे निष्पादित किया जाता है, तो स्वयं को बरकरार रखा जाता है और फिर छोड़ दिया जाता है। यदि इसे निष्पादित नहीं किया जाता है तो इसे कभी भी बरकरार नहीं रखा जाता है।

नीचे दिया गया नमूना कोड निश्चित रूप से यह दिखाता है:

import XCPlayground
XCPlaygroundPage.currentPage.needsIndefiniteExecution = true

class Person {
  init(name: String) {
    self.name = name
    print("\(name) is born.")
  }

  deinit {
    print("\(name) dies.")
  }

  var name: String

  lazy var greeting: String = {
    return "Hello \(self.name)!"
  }()

}

do {
  let t = Person(name: "Ray")
  print(t.greeting)
}

print ("Next")

// Prints: 
// Ray is born.
// Hello Ray!
// Ray dies.
// Next

do {
  let t = Person(name: "Ray")
}

print ("End of the world")

// Prints:
// Ray is born.
// Ray dies.
// End of the world

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

एक और पैटर्न जो थोड़ा कम जावास्क्रिप्ट-वाई दिख रहा है, एक निजी विधि को कॉल करना और कॉल करना है:

lazy var locationManager: CLLocationManager = self.makeLocationManager()

private func makeLocationManager() -> CLLocationManager
    let manager = CLLocationManager()
    manager.desiredAccuracy = kCLLocationAccuracyBest
    manager.delegate = self
    manager.requestAlwaysAuthorization()
    return manager
}

नोट्स की एक जोड़ी:

• मुझे यकीन नहीं है कि स्विफ्ट का कौन सा संस्करण संभव हो गया।
• कोई ढेर रिसाव नहीं; उपरोक्त समान कारण। मुझ पर विश्वास नहीं करते? कोशिश करो!
• स्थान प्रबंधक के पास एक स्पष्ट प्रकार का एनोटेशन है। यह वर्तमान में संकलक द्वारा आवश्यक है या आपको self के अनसुलझे होने के बारे में एक गुप्त त्रुटि संदेश मिलता है।
• कक्षाओं के लिए काम करता है लेकिन अपरिवर्तनीय संरचना नहीं।

यूआई घटकों के लिए जो स्टोरीबोर्ड में या बिना शर्त viewDidLoad() में आवंटित नहीं हैं, मुझे लगता है कि आलसी एक अच्छा पैटर्न है। लेकिन मुझे नहीं लगता कि मैं "आलसी सभी चीजें" कहने के लिए तैयार हूं क्योंकि इसमें अपरिवर्तनीय त्रुटियों को प्राप्त करने के लिए LazyBoxes जैसे कुछ ट्रिक्स की आवश्यकता हो सकती है।

मुझे यह उल्लेख करना चाहिए कि यद्यपि इसे स्वीकार नहीं किया गया है, फिर भी आलसी काम करने के तरीके में शायद एक बड़ा बदलाव आ रहा है:
https://github.com/apple/swift-evolution/blob/master/proposals/0030-property-behavior-decls.md

आप इस बारे में क्या सोचते हैं:

आलसी
वस्तु के जीवनकाल पर महीन अनाज नियंत्रण के लिए आलसी आरंभीकरण का उपयोग करने पर विचार करें।

// Mark: - Location services
extension MyViewController {
  lazy var locationManager: CLLocationManager = self.makeLocationManager()

  private func makeLocationManager() -> CLLocationManager
    let manager = CLLocationManager()
    manager.desiredAccuracy = kCLLocationAccuracyBest
    manager.delegate = self
    manager.requestAlwaysAuthorization()
    return manager
  }
  // :
}

मुझे वेरिएबल्स के ब्लॉक स्टाइल इनिशियलाइज़ेशन से ऐतराज नहीं है। वास्तव में, इस तरह के इनिशियलाइज़ेशन को वेरिएबल डिक्लेरेशन में डालकर एक आसान यूनिट/यूआई टेस्टिंग ओवरराइड की अनुमति मिलती है।

वैसे स्थान प्रबंधक को वर्ग संपत्ति के रूप में परिभाषित करें क्योंकि प्रबंधक असाइन करने के कारण काम नहीं कर रहा है। प्रतिनिधि = स्वयं

आपका क्या सुझाव है?

बस अपनी कक्षा (नियंत्रक देखें?) को CLLocationManagerDelegate के अनुरूप बनाएं।

@rayfix मैंने इस स्निपेट को सुपर क्लास में स्थानांतरित कर दिया है। मैं आधार पर CLLocationManagerDelegate प्रोटोकॉल को शामिल करने से चूक गया।

धन्यवाद

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

https://twitter.com/jckarter/status/704100315587477504

ध्यान रखें कि आप अभी भी अन्य तरीकों से स्वयं को पकड़ने में सक्षम हो सकते हैं (उदाहरण के लिए एक आलसी संस्करण के भीतर स्वयं को पकड़ने वाले ब्लॉक चर)

बस आपको यह बताना चाहता हूं कि एक्सकोड 8 में नए मेमोरी ग्राफ व्यू का उपयोग करके मैंने पाया कि एक कैप्चर था जब मैंने निम्नलिखित में अज्ञात स्वयं निर्माण का उपयोग नहीं किया:

lazy var locationManager: CLLocationManager = {
    [unowned self] in
    var _locationManager = CLLocationManager()
    _locationManager.delegate = self
    _locationManager.desiredAccuracy = Set.shared.trackingAccuracy
    _locationManager.allowsBackgroundLocationUpdates = true
    _locationManager.activityType = .fitness      
    _locationManager.distanceFilter = Double(Set.shared.waypointInterval)
    return _locationManager
}()

लेकिन ऐसा तब नहीं हुआ जब मैंने इसे शामिल किया और कोई अन्य परिवर्तन नहीं किया।

@rondiel ध्यान दें कि CLLocationManager के प्रतिनिधि को असाइन (iOS 10 SDK) के रूप में घोषित किया गया है
@property(assign, nonatomic, nullable) id<CLLocationManagerDelegate> delegate;