Як правильно поводитись із слабким самоврядом у швидких блоках із аргументами

В моєму 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:

Різниця між блоком (Завдання C) і закриттям (Swift) в ios

Поставте [unowned self]перед тим, як (text: String)...закрити. Це називається списком захоплення та розміщує інструкції щодо власності на символи, захоплені під час закриття.

** ВИДАЛЕНО для Swift 4.2:

Як прокоментував @Koen, швидкий 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 прокоментував, Кріс Леттнер сказав пт. 22 січня 19:51:29 CST 2016, цей трюк не слід використовувати самостійно, тому, будь ласка, не використовуйте його. Перевірте інформацію про незакриття закриття та відповідь зі списку захоплення від @gbk. **

Для тих, хто використовує [слабке "у списку захоплення, зауважте, що самодоступність може бути нульовою, тому перше, що я роблю, - це перевірити це з заявою охорони

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

Якщо вам цікаво, що навколо лапок, це непростийself трюк, щоб використовувати себе всередині закриття, не потребуючи змінити ім'я на це , слабкий стиль чи інше.

Використовуйте список захоплення

Визначення списку захоплення

Кожен елемент у списку захоплення - це сполучення слабкого або невідомого ключового слова з посиланням на екземпляр класу (наприклад, self) або змінну, ініціалізовану з деяким значенням (наприклад, delegate = 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
}

додаткові пояснення

EDIT: Посилання на оновлене рішення 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]

Якщо ви збиваєтеся, ніж вам, мабуть, потрібен [слабкий я]

Я здогадуюсь, що блок, який ви створюєте, якимось чином провіднаний.

Створіть файл ReadyForReuse і спробуйте очистити блок onTextViewEditClosure всередині цього.

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

Подивіться, чи це запобігає аварії. (Це просто здогад).

Закриття та потужні еталонні цикли ^[Про]

Як ви знаєте, закриття Swift може захопити екземпляр. Це означає, що ви можете використовувати selfвсередину закриття. Особливо escaping closure^[About] може створити strong reference cycleякий. До речі, ви повинні явно використовувати selfвсередині escaping 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 - використовуйте його, коли ви впевнені, що термін служби власника екземпляра більший, ніж час закриття