Cómo manejar correctamente el yo débil en bloques rápidos con argumentos

En mi TextViewTableViewCell, tengo una variable para realizar un seguimiento de un bloque y un método de configuración donde el bloque se pasa y se asigna.
Aquí está mi TextViewTableViewCellclase:

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

Cuando uso el método de configuración en mi cellForRowAtIndexPathmétodo, ¿cómo utilizo correctamente el yo débil en el bloque que paso? Esto
es lo que tengo sin el yo débil:

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

ACTUALIZACIÓN : Tengo lo siguiente para trabajar usando [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

Cuando lo hago en [unowned self]lugar de [weak self]y saco la ifdeclaración, la aplicación se bloquea. ¿Alguna idea sobre cómo debería funcionar esto [unowned self]?

Si el self puede ser nulo en el cierre, use [self débil] .

Si el self nunca será nulo en el cierre, use [self sin dueño] .

Si se cuelga cuando usas [yo sin propiedad] , supongo que ese yo es nulo en algún momento de ese cierre, por lo que tuviste que ir con [yo débil] .

Realmente me gustó toda la sección del manual sobre el uso de cierres fuertes , débiles y sin propiedad:

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

Nota: utilicé el término cierre en lugar de bloque, que es el término Swift más nuevo:

Diferencia entre bloqueo (Objetivo C) y cierre (Swift) en ios

Poner [unowned self]antes (text: String)...en su cierre. Esto se llama una lista de captura y coloca instrucciones de propiedad sobre los símbolos capturados en el cierre.

** EDITADO para Swift 4.2:

Como comentó @Koen, swift 4.2 permite:

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

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

PD: Dado que tengo algunos votos positivos, me gustaría recomendar la lectura sobre cómo escapar de los cierres .

EDITADO: Como ha comentado @ tim-vermeulen, Chris Lattner dijo el viernes 22 de enero a las 19:51:29 CST 2016, este truco no debe usarse solo, así que no lo use. Verifique la información de los cierres que no escapan y la respuesta de la lista de captura de @gbk. **

Para aquellos que usan [self débil] en la lista de captura, tenga en cuenta que self podría ser nulo, por lo que lo primero que hago es verificar eso con una declaración de guardia

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

Si se pregunta cuáles son las comillas, selfes un truco profesional para usar uno mismo dentro del cierre sin necesidad de cambiar el nombre a este , débilSelf o lo que sea.

Usar lista de captura

Definir una lista de captura

Cada elemento en una lista de captura es un emparejamiento de la palabra clave débil o no propiedad con una referencia a una instancia de clase (como self) o una variable inicializada con algún valor (como delegate = self.delegate!). Estos emparejamientos se escriben dentro de un par de llaves cuadradas, separadas por comas.

Coloque la lista de captura antes de una lista de parámetros de cierre y tipo de retorno si se proporcionan:

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

Si un cierre no especifica una lista de parámetros o un tipo de retorno porque pueden inferirse del contexto, coloque la lista de captura al comienzo del cierre, seguido de la palabra clave in:

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

explicaciones adicionales

EDITAR: referencia a una solución actualizada de LightMan

Ver la solución de LightMan . Hasta ahora estaba 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
}

Por lo general, no necesita especificar el tipo de parámetro si se infiere.

Puede omitir el parámetro por completo si no hay ninguno o si se refiere a él como $0en el cierre:

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

Solo para completar; Si pasa el cierre a una función y el parámetro no lo es @escaping, no necesita un weak self:

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

A partir de swift 4.2 🔸 podemos hacer:

_ = { [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

Puede usar [yo débil] o [yo no propio] en la lista de captura antes de sus parámetros del bloque. La lista de captura es una sintaxis opcional.

[unowned self]funciona bien aquí porque la celda nunca será nula. De lo contrario, puede usar[weak self]

Si se estrella de lo que probablemente necesite [yo débil]

Supongo que el bloque que está creando todavía está conectado de alguna manera.

Cree un prepareForReuse e intente borrar el bloque onTextViewEditClosure dentro de eso.

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

Vea si eso previene el choque. (Es solo una suposición).

Cierre y fuertes ciclos de referencia ^{[Acerca de]}

Como saben, el cierre de Swift puede capturar la instancia. Significa que puede usar selfdentro de un cierre. Especialmente escaping closure^{[Acerca de]} puede crear un strong reference cycleque. Por cierto, tienes que usar explícitamente selfdentro escaping closure.

El cierre rápido tiene una Capture Listfunción que le permite evitar tal situación y romper un ciclo de referencia porque no tiene una referencia fuerte a la instancia capturada. El elemento Lista de captura es un par de weak/ unownedy una referencia a clase o variable.

Por ejemplo

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- más preferible, úselo cuando sea posible
• unowned - Úselo cuando esté seguro de que la vida útil del propietario de la instancia es mayor que el cierre