Cara Benar Menangani Lemah di Blok Swift dengan Argumen

Di saya TextViewTableViewCell, saya punya variabel untuk melacak blok dan metode konfigurasi tempat blok dilewatkan dan ditugaskan.
Ini TextViewTableViewCellkelas saya :

//
//  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)
        }
    }
}

Ketika saya menggunakan metode configure dalam metode saya cellForRowAtIndexPath, bagaimana cara menggunakan diri lemah di blok yang saya lewati.
Berikut adalah apa yang saya miliki tanpa diri lemah:

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

PEMBARUAN : Saya mendapat yang berikut untuk bekerja menggunakan [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

Ketika saya melakukan dan [unowned self]bukannya [weak self]mengeluarkan ifpernyataan itu, aplikasi mogok. Ada ide tentang bagaimana ini harus bekerja [unowned self]?

Jika diri bisa nol dalam penutupan gunakan [diri lemah] .

Jika diri tidak akan pernah nol dalam penutupan gunakan [diri yang tidak dimiliki] .

Jika crash ketika Anda menggunakan [diri yang tidak dimiliki] saya akan menebak bahwa diri adalah nol di beberapa titik dalam penutupan itu, itulah sebabnya Anda harus pergi dengan [diri yang lemah] sebagai gantinya.

Saya benar-benar menyukai seluruh bagian dari manual tentang penggunaan kuat , lemah , dan tidak dimiliki dalam penutupan:

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

Catatan: Saya menggunakan istilah penutupan alih-alih blok yang merupakan istilah Swift yang lebih baru:

Perbedaan antara blok (Objective C) dan closure (Swift) di ios

Masukkan [unowned self]sebelum (text: String)...di penutupan Anda. Ini disebut daftar penangkapan dan menempatkan instruksi kepemilikan pada simbol yang ditangkap di penutupan.

** DIedit untuk Swift 4.2:

Seperti yang dikomentari @Koen, swift 4.2 memungkinkan:

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

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

PS: Karena saya mendapat suara, saya ingin merekomendasikan bacaan tentang lolos dari penutupan .

Diedit: Seperti yang dikomentari @ tim-vermeulen, Chris Lattner mengatakan pada Jumat 22 Januari 19:51:29 CST 2016, trik ini tidak boleh digunakan pada diri sendiri, jadi tolong jangan gunakan itu. Periksa info penutupan yang tidak lolos dan jawaban daftar tangkap dari @ gbk. **

Bagi mereka yang menggunakan [diri lemah] dalam daftar tangkap, perhatikan bahwa diri bisa nol, jadi hal pertama yang saya lakukan adalah memeriksa dengan pernyataan penjaga

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

Jika Anda bertanya-tanya apa tanda kutip ada di sekitar selfadalah trik pro untuk menggunakan diri di dalam penutupan tanpa perlu mengubah nama untuk ini , diri lemah atau apa pun.

Gunakan daftar Tangkap

Menentukan Daftar Capture

Setiap item dalam daftar tangkap adalah pasangan kata kunci yang lemah atau tidak dimiliki dengan referensi ke instance kelas (seperti diri sendiri) atau variabel yang diinisialisasi dengan beberapa nilai (seperti delegate = self.delegate!). Pasangan ini ditulis dalam sepasang kawat gigi persegi, dipisahkan dengan koma.

Tempatkan daftar tangkap sebelum daftar parameter penutupan dan ketik kembali jika disediakan:

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

Jika penutupan tidak menentukan daftar parameter atau tipe pengembalian karena mereka dapat disimpulkan dari konteks, tempatkan daftar penangkapan di awal penutupan, diikuti dengan kata kunci in:

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

penjelasan tambahan

EDIT: Referensi ke solusi yang diperbarui oleh LightMan

Lihat solusi LightMan . Sampai sekarang saya menggunakan:

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

Atau:

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

Biasanya Anda tidak perlu menentukan tipe parameter jika disimpulkan.

Anda dapat menghilangkan parameter sama sekali jika tidak ada atau jika Anda merujuknya seperti $0pada penutupan:

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

Hanya untuk kelengkapan; jika Anda meneruskan penutupan ke suatu fungsi dan parameter tidak @escaping, Anda tidak perlu weak self:

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

Mulai dari 4.2 🔸 yang dapat kita lakukan:

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

Cepat 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

Anda dapat menggunakan [diri lemah] atau [diri tidak dimiliki] dalam daftar penangkapan sebelum parameter blok Anda. Daftar penangkapan adalah sintaks opsional.

[unowned self]bekerja dengan baik di sini karena sel tidak akan pernah menjadi nol. Kalau tidak, Anda bisa menggunakan[weak self]

Jika Anda menabrak dari yang Anda butuhkan [lemah diri]

Dugaan saya adalah bahwa blok yang Anda buat entah bagaimana masih terhubung.

Buat preparForReuse dan coba bersihkan blok onTextViewEditClosure di dalamnya.

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

Lihat apakah itu mencegah crash. (Itu hanya tebakan).

Penutupan dan siklus referensi yang kuat ^[Tentang]

Seperti yang Anda tahu penutupan Swift dapat menangkap contoh. Ini berarti bahwa Anda dapat menggunakan selfdi dalam penutupan. Terutama escaping closure^[Tentang] dapat membuat strong reference cycleapa. Ngomong-ngomong, Anda harus menggunakan selfdi dalam secara eksplisitescaping closure .

Penutupan Swift memiliki Capture Listfitur yang memungkinkan Anda menghindari situasi seperti itu dan memutus siklus referensi karena tidak memiliki referensi yang kuat untuk instance yang ditangkap. Elemen Capture List adalah sepasang weak/unowned dan referensi ke kelas atau variabel.

Sebagai contoh

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- lebih disukai, gunakan jika memungkinkan
• unowned - gunakan ketika Anda yakin bahwa pemilik instance seumur hidup lebih besar dari penutupan