วิธีการจัดการ Weak Self ที่ถูกต้องในบล็อก Swift ด้วยอาร์กิวเมนต์อย่างถูกต้อง

ในตัวฉันTextViewTableViewCellฉันมีตัวแปรที่จะติดตามบล็อกและวิธีกำหนดค่าที่บล็อกถูกส่งผ่านและกำหนด
นี่คือTextViewTableViewCellชั้นเรียนของฉัน:

//
//  TextViewTableViewCell.swift
//

import UIKit

class TextViewTableViewCell: UITableViewCell, UITextViewDelegate {

    @IBOutlet var textView : UITextView

    var onTextViewEditClosure : ((text : String) -> Void)?

    func configure(#text: String?, onTextEdit : ((text : String) -> Void)) {
        onTextViewEditClosure = onTextEdit
        textView.delegate = self
        textView.text = text
    }

    // #pragma mark - Text View Delegate

    func textViewDidEndEditing(textView: UITextView!) {
        if onTextViewEditClosure {
            onTextViewEditClosure!(text: textView.text)
        }
    }
}

เมื่อฉันใช้วิธีกำหนดค่าในวิธีการของฉันฉันcellForRowAtIndexPathจะใช้ตัวเองที่อ่อนแอในบล็อกที่ฉันผ่านได้อย่างไร
นี่คือสิ่งที่ฉันมีโดยไม่มีตัวตนที่อ่อนแอ:

let myCell = tableView.dequeueReusableCellWithIdentifier(textViewCellIdenfitier) as TextViewTableViewCell
myCell.configure(text: body, onTextEdit: {(text: String) in
   // THIS SELF NEEDS TO BE WEAK  
   self.body = text
})
cell = bodyCell

อัปเดต : ฉันได้รับการทำงานดังต่อไปนี้โดยใช้[weak self]:

let myCell = tableView.dequeueReusableCellWithIdentifier(textViewCellIdenfitier) as TextViewTableViewCell
myCell.configure(text: body, onTextEdit: {[weak self] (text: String) in
        if let strongSelf = self {
             strongSelf.body = text
        }
})
cell = myCell

เมื่อฉันทำ[unowned self]แทน[weak self]และนำifคำสั่งออกมาแอปขัดข้อง ความคิดใด ๆ เกี่ยวกับวิธีการนี้ควรจะทำงานกับ[unowned self]?

ถ้าตัวเองอาจจะเป็นศูนย์ในการใช้งานปิด[อ่อนแอตนเอง]

ถ้า ตัวเองไม่เคยจะเป็นศูนย์ในการใช้งานปิด[ไม่มีเจ้าของตัวเอง]

ถ้ามันพังเมื่อคุณใช้ [ตัวเองไม่มีกรรมสิทธิ์]ฉันจะเดาว่าตัวเองไม่มีอะไรเลยในช่วงเวลานั้นซึ่งเป็นเหตุผลว่าทำไมคุณต้องไปกับ[ตัวอ่อนแอ]แทน

ผมชอบส่วนทั้งจากคู่มือเกี่ยวกับการใช้ที่แข็งแกร่ง , อ่อนแอและไม่มีเจ้าของในการปิด:

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html

หมายเหตุ: ฉันใช้คำว่าปิดแทนบล็อกซึ่งเป็นเทอมใหม่ของ Swift:

ความแตกต่างระหว่างบล็อก (Objective C) และการปิด (Swift) ใน ios

ใส่[unowned self]ก่อน(text: String)...ในการปิดของคุณ สิ่งนี้เรียกว่ารายการจับภาพและวางคำแนะนำการเป็นเจ้าของสัญลักษณ์ที่ถูกจับในการปิด

** แก้ไขสำหรับ Swift 4.2:

ในฐานะที่ @Koen แสดงความคิดเห็น swift 4.2 ช่วยให้:

guard let self = self else {
   return // Could not get a strong reference for self :`(
}

// Now self is a strong reference
self.doSomething()

PS: ตั้งแต่ฉันมีบางอย่างขึ้นเสียงผมอยากจะขอแนะนำให้อ่านเกี่ยวกับการปิดการหลบหนี

แก้ไข: ตามที่ @ tim-vermeulen แสดงความคิดเห็น Chris Lattner กล่าวเมื่อวันศุกร์ที่ 22 มกราคม 19:51:29 CST 2016 เคล็ดลับนี้ไม่ควรใช้กับตัวเองดังนั้นโปรดอย่าใช้ ตรวจสอบข้อมูลการปิดไม่ใช่การหลบหนีและคำตอบรายการบันทึกภาพจาก @gbk. **

สำหรับผู้ที่ใช้ [อ่อนแอตัวเอง] ในรายการบันทึกโปรดทราบว่าตนเองอาจเป็นศูนย์ดังนั้นสิ่งแรกที่ฉันต้องทำคือตรวจสอบด้วยคำแถลงยาม

guard let `self` = self else {
   return
}
self.doSomething()

หากคุณกำลังสงสัยว่าเครื่องหมายคำพูดที่มีรอบselfเป็นเคล็ดลับที่จะใช้โปรตนเองภายในปิดโดยไม่จำเป็นต้องเปลี่ยนชื่อนี้ , weakSelfหรืออะไรก็ตาม

ใช้รายการจับภาพ

การกำหนดรายการจับภาพ

แต่ละรายการในรายการจับภาพคือการจับคู่ของคำหลักที่อ่อนแอหรือไม่มีเจ้าของที่มีการอ้างอิงถึงอินสแตนซ์ของชั้นเรียน (เช่นตนเอง) หรือตัวแปรเริ่มต้นด้วยค่าบางอย่าง (เช่นมอบหมาย = self.delegate!) การจับคู่เหล่านี้เขียนขึ้นภายในวงเล็บปีกกาสองอันคั่นด้วยเครื่องหมายจุลภาค

วางรายการการดักจับไว้หน้ารายการพารามิเตอร์ของการปิดและประเภทการส่งคืนหากมีการจัดเตรียมไว้ให้:

lazy var someClosure: (Int, String) -> String = {
    [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
    // closure body goes here 
} 

หากการปิดไม่ได้ระบุรายการพารามิเตอร์หรือชนิดส่งคืนเนื่องจากสามารถสรุปได้จากบริบทให้วางรายการจับภาพที่จุดเริ่มต้นของการปิดตามด้วยคำหลักใน:

lazy var someClosure: Void -> String = {
    [unowned self, weak delegate = self.delegate!] in
    // closure body goes here
}

คำอธิบายเพิ่มเติม

แก้ไข: อ้างอิงถึงโซลูชันที่อัปเดตโดย LightMan

ดูวิธีการแก้ปัญหาของ Lightman จนถึงตอนนี้ฉันกำลังใช้:

input.action = { [weak self] value in
    guard let this = self else { return }
    this.someCall(value) // 'this' isn't nil
}

หรือ:

input.action = { [weak self] value in
    self?.someCall(value) // call is done if self isn't nil
}

โดยปกติคุณไม่จำเป็นต้องระบุประเภทพารามิเตอร์หากอนุมาน

คุณสามารถละเว้นพารามิเตอร์ทั้งหมดได้หากไม่มีหรืออ้างถึงในขณะ$0ที่ปิด:

input.action = { [weak self] in
    self?.someCall($0) // call is done if self isn't nil
}

เพียงเพื่อความสมบูรณ์ หากคุณผ่านการปิดฟังก์ชันและพารามิเตอร์ไม่ใช่@escapingคุณไม่จำเป็นต้องweak self:

[1,2,3,4,5].forEach { self.someCall($0) }

จากความรวดเร็ว 4.2 🔸เราทำได้:

_ = { [weak self] value in
    guard let self = self else { return }
    print(self) //👈 will never be nil
}()

สวิฟต์ 4.2

let closure = { [weak self] (_ parameter:Int) in
    guard let self = self else { return }

    self.method(parameter)
}

https://github.com/apple/swift-evolution/blob/master/proposals/0079-upgrade-self-from-weak-to-strong.md

คุณสามารถใช้ [ตัวเองอ่อนแอ] หรือ [ตัวเองไม่มีกรรมสิทธิ์] ในรายการจับภาพก่อนพารามิเตอร์ของบล็อก รายการจับภาพเป็นไวยากรณ์ตัวเลือก

[unowned self]ทำงานได้ดีที่นี่เพราะเซลล์จะไม่มีศูนย์ มิฉะนั้นคุณสามารถใช้[weak self]

หากคุณล้มเหลวกว่าที่คุณต้องการ [ตัวอ่อนแอ]

ฉันเดาว่าบล็อกที่คุณกำลังสร้างยังคงมีสายอยู่บ้าง

สร้าง PreparForReuse และลองล้างบล็อค onTextViewEditClosure ข้างในนั้น

func prepareForResuse() {
   onTextViewEditClosure = nil
   textView.delegate = nil
}

ดูว่าช่วยป้องกันความผิดพลาดหรือไม่ (มันเป็นเพียงการคาดเดา)

การปิดและรอบการอ้างอิงที่แข็งแกร่ง^{[เกี่ยวกับ]}

ดังที่คุณทราบการปิดตัวของ Swift นั้นสามารถจับภาพได้ หมายความว่าคุณสามารถใช้งานได้selfในการปิด โดยเฉพาะescaping closure^{[เกี่ยวกับ]}สามารถสร้างสิ่งstrong reference cycleที่ โดยวิธีการที่คุณต้องใช้อย่างชัดเจนภายในselfescaping closure

การปิดสวิฟท์มีCapture Listคุณสมบัติที่ช่วยให้คุณสามารถหลีกเลี่ยงสถานการณ์ดังกล่าวและทำลายวงจรการอ้างอิงได้เนื่องจากไม่มีการอ้างอิงที่แข็งแกร่งสำหรับอินสแตนซ์ที่ถูกจับ องค์ประกอบรายการบันทึกภาพเป็นคู่ของweak/unownedและการอ้างอิงถึงคลาสหรือตัวแปร

ตัวอย่างเช่น

class A {
    private var completionHandler: (() -> Void)!
    private var completionHandler2: ((String) -> Bool)!

    func nonescapingClosure(completionHandler: () -> Void) {
        print("Hello World")
    }

    func escapingClosure(completionHandler: @escaping () -> Void) {
        self.completionHandler = completionHandler
    }

    func escapingClosureWithPArameter(completionHandler: @escaping (String) -> Bool) {
        self.completionHandler2 = completionHandler
    }
}

class B {
    var variable = "Var"

    func foo() {
        let a = A()

        //nonescapingClosure
        a.nonescapingClosure {
            variable = "nonescapingClosure"
        }

        //escapingClosure
        //strong reference cycle
        a.escapingClosure {
            self.variable = "escapingClosure"
        }

        //Capture List - [weak self]
        a.escapingClosure {[weak self] in
            self?.variable = "escapingClosure"
        }

        //Capture List - [unowned self]
        a.escapingClosure {[unowned self] in
            self.variable = "escapingClosure"
        }

        //escapingClosureWithPArameter
        a.escapingClosureWithPArameter { [weak self] (str) -> Bool in
            self?.variable = "escapingClosureWithPArameter"
            return true
        }
    }
}

• weak- เป็นที่นิยมมากกว่าใช้เมื่อเป็นไปได้
• unowned - ใช้เมื่อคุณแน่ใจว่าอายุการใช้งานของเจ้าของอินสแตนซ์นั้นใหญ่กว่าการปิด