Wie man mit schwachen Selbst in schnellen Blöcken mit Argumenten richtig umgeht

In meinem habe TextViewTableViewCellich eine Variable, um einen Block zu verfolgen, und eine Konfigurationsmethode, bei der der Block übergeben und zugewiesen wird.
Hier ist meine TextViewTableViewCellKlasse:

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

Wenn ich die configure-Methode in meiner cellForRowAtIndexPathMethode verwende, wie verwende ich das schwache Selbst in dem Block, den ich übergebe, richtig?
Folgendes habe ich ohne das schwache Selbst:

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

UPDATE : Ich habe Folgendes zum Arbeiten [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

Wenn ich die Anweisung [unowned self]anstelle von [weak self]und ifherausnehme, stürzt die App ab. Irgendwelche Ideen, wie das funktionieren soll [unowned self]?

Wenn das Selbst im Verschluss gleich Null sein könnte, benutze [schwaches Selbst] .

Wenn das Selbst im Verschluss niemals Null sein wird, verwenden Sie [nicht besessenes Selbst] .

Wenn es abstürzt, wenn Sie [nicht besessenes Selbst] verwenden, würde ich vermuten, dass das Selbst irgendwann in diesem Abschluss gleich Null ist, weshalb Sie stattdessen mit [schwachem Selbst] gehen mussten .

Ich mochte den gesamten Abschnitt aus dem Handbuch über die Verwendung von starken , schwachen und nicht besessenen Verschlüssen sehr:

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

Hinweis: Ich habe den Begriff Closure anstelle von Block verwendet, der der neuere Swift-Begriff ist:

Unterschied zwischen Block (Ziel C) und Abschluss (Swift) in ios

Setzen Sie [unowned self]vorher (text: String)...in Ihren Verschluss. Dies wird als Erfassungsliste bezeichnet und platziert Besitzanweisungen für Symbole, die im Abschluss erfasst wurden.

** BEARBEITET für Swift 4.2:

Wie @Koen kommentierte, erlaubt 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: Da ich einige Up-Votes habe, möchte ich die Lektüre über die Flucht vor Schließungen empfehlen .

BEARBEITET: Wie @ tim-vermeulen kommentiert hat, sagte Chris Lattner am Fri Jan 22 19:51:29 CST 2016, dieser Trick sollte nicht für sich selbst verwendet werden, also bitte nicht verwenden. Überprüfen Sie die Informationen zu nicht entkommenden Schließungen und die Antwort auf die Erfassungsliste von @gbk. **

Beachten Sie für diejenigen, die [schwaches Selbst] in der Erfassungsliste verwenden, dass Selbst Null sein kann. Als erstes überprüfe ich dies mit einer Guard-Anweisung

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

Wenn Sie sich fragen, um welche Anführungszeichen es sich handelt, selfist dies ein Pro-Trick, um sich selbst innerhalb des Verschlusses zu verwenden, ohne den Namen in dies , schwaches Selbst oder was auch immer ändern zu müssen .

Verwenden Sie Capture - Liste

Erfassen einer Erfassungsliste

Jedes Element in einer Erfassungsliste ist eine Paarung des schwachen oder nicht besessenen Schlüsselworts mit einem Verweis auf eine Klasseninstanz (z. B. self) oder eine Variable, die mit einem bestimmten Wert initialisiert wurde (z. B. delegate = self.delegate!). Diese Paarungen werden in zwei eckigen Klammern geschrieben, die durch Kommas getrennt sind.

Platzieren Sie die Erfassungsliste vor der Parameterliste eines Abschlusses und geben Sie den Rückgabetyp zurück, falls diese bereitgestellt werden:

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

Wenn ein Abschluss keine Parameterliste oder keinen Rückgabetyp angibt, da diese aus dem Kontext abgeleitet werden können, platzieren Sie die Erfassungsliste ganz am Anfang des Abschlusses, gefolgt vom Schlüsselwort in:

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

zusätzliche Erklärungen

BEARBEITEN: Verweis auf eine aktualisierte Lösung von LightMan

Siehe LightMans Lösung . Bis jetzt habe ich verwendet:

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

Oder:

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

Normalerweise müssen Sie den Parametertyp nicht angeben, wenn er abgeleitet wird.

Sie können den Parameter ganz weglassen, wenn es keinen gibt oder wenn Sie sich wie $0im Abschluss darauf beziehen :

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

Nur der Vollständigkeit halber; Wenn Sie den Abschluss an eine Funktion übergeben und der Parameter nicht @escaping, benötigen Sie kein weak self:

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

Ab Swift 4.2 🔸 können wir:

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

Swift 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

Sie können [schwaches Selbst] oder [nicht besessenes Selbst] in der Erfassungsliste vor Ihren Parametern des Blocks verwenden. Die Erfassungsliste ist eine optionale Syntax.

[unowned self]funktioniert hier gut, weil die Zelle niemals Null sein wird. Ansonsten können Sie verwenden[weak self]

Wenn Sie abstürzen, brauchen Sie wahrscheinlich [schwaches Selbst]

Ich vermute, dass der Block, den Sie erstellen, irgendwie immer noch verkabelt ist.

Erstellen Sie eine prepareForReuse und versuchen Sie, den darin enthaltenen onTextViewEditClosure-Block zu löschen.

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

Überprüfen Sie, ob dies den Absturz verhindert. (Es ist nur eine Vermutung).

Abschluss und starke Referenzzyklen ^[About]

Wie Sie wissen, kann Swifts Schließung die Instanz erfassen. Dies bedeutet, dass Sie selfin einem Verschluss verwenden können. Insbesondere escaping closure^[About] kann ein strong reference cyclewelche erstellen . Übrigens muss man selfdrinnen explizit verwenden escaping closure.

Das schnelle Schließen verfügt über eine Capture ListFunktion, mit der Sie eine solche Situation vermeiden und einen Referenzzyklus unterbrechen können, da Sie keinen starken Bezug zur erfassten Instanz haben. Das Capture List-Element ist ein Paar von weak/ unownedund ein Verweis auf eine Klasse oder Variable.

Beispielsweise

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- bevorzugter, verwenden Sie es, wenn es möglich ist
• unowned - Verwenden Sie es, wenn Sie sicher sind, dass die Lebensdauer des Instanzeigners länger ist als die Schließung