Come gestire correttamente l'auto debole in blocchi rapidi con argomenti

Nel mio TextViewTableViewCell, ho una variabile per tenere traccia di un blocco e un metodo di configurazione in cui il blocco viene passato e assegnato.
Ecco la mia TextViewTableViewCellclasse:

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

Quando uso il metodo configure nel mio cellForRowAtIndexPathmetodo, come posso usare correttamente il sé debole nel blocco in cui passo.
Ecco cosa ho senza il sé debole:

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

AGGIORNAMENTO : Ho ottenuto quanto segue per funzionare utilizzando [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

Quando lo faccio [unowned self]anziché [weak self]estrarre la ifdichiarazione, l'app si arresta in modo anomalo. Qualche idea su come dovrebbe funzionare [unowned self]?

Se il sé potrebbe essere nullo nella chiusura usa [sé debole] .

Se il sé non sarà mai nullo nella chiusura, usa [sé sconosciuto] .

Se si arresta in modo anomalo quando si utilizza [un sé sconosciuto] , immagino che il sé sia ​​nullo a un certo punto in quella chiusura, motivo per cui invece si è dovuto andare con [sé debole] .

Mi è davvero piaciuta l'intera sezione del manuale sull'uso di chiusure forti , deboli e sconosciute :

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

Nota: ho usato il termine chiusura anziché blocco, che è il nuovo termine Swift:

Differenza tra blocco (obiettivo C) e chiusura (rapido) in iOS

Metti [unowned self]prima (text: String)...nella tua chiusura. Questo si chiama un elenco di acquisizione e inserisce le istruzioni di proprietà sui simboli acquisiti nella chiusura.

** MODIFICATO per Swift 4.2:

Come ha commentato @Koen, swift 4.2 consente:

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

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

PS: Dato che sto avendo alcuni voti positivi, vorrei raccomandare la lettura sulla fuga dalle chiusure .

EDITED: Come ha commentato @ tim-vermeulen, Chris Lattner ha detto venerdì 22 gennaio 19:51:29 CST 2016, questo trucco non dovrebbe essere usato da solo, quindi per favore non usarlo. Controlla le informazioni sulle chiusure non in fuga e la risposta dell'elenco di acquisizione da @gbk. **

Per coloro che usano [sé debole] nell'elenco di acquisizione, nota che il sé potrebbe essere nullo, quindi la prima cosa che faccio è verificarlo con un'istruzione guard

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

Se ti stai chiedendo quali sono le virgolette, selfè un trucco da usare se stessi all'interno della chiusura senza dover cambiare il nome in questo , debole Se stesso o altro.

Usa l' elenco di acquisizione

Definizione di un elenco di acquisizione

Ogni elemento in un elenco di acquisizione è un'associazione della parola chiave debole o non definita con un riferimento a un'istanza di classe (come self) o una variabile inizializzata con un valore (come delegate = self.delegate!). Questi accoppiamenti sono scritti all'interno di una coppia di parentesi quadre, separati da virgole.

Posizionare l'elenco di acquisizione prima dell'elenco dei parametri di una chiusura e restituire il tipo se sono forniti:

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

Se una chiusura non specifica un elenco di parametri o un tipo restituito perché possono essere dedotti dal contesto, posizionare l'elenco di acquisizione all'inizio della chiusura, seguito dalla parola chiave in:

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

spiegazioni aggiuntive

EDIT: riferimento a una soluzione aggiornata di LightMan

Vedi la soluzione di LightMan . Fino ad ora stavo usando:

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

O:

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

Di solito non è necessario specificare il tipo di parametro se inferito.

Puoi omettere del tutto il parametro se non ce ne sono o se ti riferisci ad esso come $0nella chiusura:

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

Solo per completezza; se si passa la chiusura a una funzione e il parametro non lo è @escaping, non è necessario un weak self:

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

A partire dal rapido 4.2 🔸 possiamo fare:

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

Rapido 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

È possibile utilizzare [sé debole] o [sé sconosciuto] nell'elenco di acquisizione prima dei parametri del blocco. L'elenco di acquisizione è una sintassi opzionale.

[unowned self]funziona bene qui perché la cella non sarà mai nulla. Altrimenti puoi usare[weak self]

Se stai andando in crash di quanto probabilmente hai bisogno di [sé debole]

La mia ipotesi è che il blocco che stai creando sia in qualche modo ancora cablato.

Crea un preparForReuse e prova a cancellare il blocco onTextViewEditClosure al suo interno.

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

Vedi se questo impedisce l'incidente. (È solo una supposizione).

Chiusura e forti cicli di riferimento ^{[Informazioni]}

Come sapete, la chiusura di Swift può catturare l'istanza. Significa che puoi usare selfall'interno di una chiusura. Soprattutto escaping closure^{[Informazioni]} può creare un strong reference cyclequale. A proposito, devi usare esplicitamente selfdentro escaping closure.

La chiusura rapida ha Capture Listfunzionalità che consentono di evitare tale situazione e interrompere un ciclo di riferimento perché non hanno un forte riferimento all'istanza acquisita. L'elemento Capture List è una coppia di weak/ unownede un riferimento a classe o variabile.

Per esempio

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- più preferibile, usalo quando è possibile
• unowned - usalo quando sei sicuro che la durata del proprietario dell'istanza sia maggiore della chiusura