Jak poprawnie radzić sobie ze słabą jaźnią w szybkich blokach za pomocą argumentów

W moim TextViewTableViewCellmam zmienną do śledzenia bloku i metodę konfiguracji, w której blok jest przekazywany i przypisywany.
Oto moja TextViewTableViewCellklasa:

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

Kiedy używam metody konfiguracji w mojej cellForRowAtIndexPathmetodzie, jak prawidłowo używać słabego Ja w bloku, który przekazuję.
Oto, co mam bez słabego Ja:

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 : Do pracy przy użyciu [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

Kiedy robię to [unowned self]zamiast [weak self]i wyciągam ifoświadczenie, aplikacja ulega awarii. Jakieś pomysły, jak to powinno działać [unowned self]?

Jeśli jaźń może być zerowa w zamknięciu, użyj [słabe ja] .

Jeśli jaźń nigdy nie będzie zerowa w zamknięciu, użyj [nieposiadanego ja] .

Jeśli to się zawiesza, kiedy używasz [nieposiadanego ja] , przypuszczam, że w pewnym momencie tego zamknięcia jaźń jest zerowa, dlatego zamiast tego musiałeś iść z [słabym ja] .

Bardzo podobał mi się cały rozdział podręcznika dotyczący używania mocnych , słabych i nieposiadanych w zamknięciach:

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

Uwaga: użyłem terminu zamknięcie zamiast bloku, który jest nowszym terminem Swift:

Różnica między blokiem (Cel C) a zamknięciem (Swift) w iOS

Umieść [unowned self]przed (text: String)...zamknięciem. Nazywa się to listą przechwytywania i umieszcza instrukcje dotyczące własności na symbolach przechwyconych w zamknięciu.

** EDYTOWANE dla Swift 4.2:

Jak skomentował @Koen, Swift 4.2 umożliwia:

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

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

PS: Ponieważ mam kilka pozytywnych głosów, chciałbym polecić lekturę o unikaniu zamknięć .

ZMIENIONO: Jak skomentował @ tim-vermeulen, Chris Lattner powiedział w piątek, 22 stycznia, 19:51:29 CST 2016, ta sztuczka nie powinna być używana na sobie, więc proszę jej nie używać. Sprawdź informacje o zamknięciach bez ucieczki i odpowiedź na listę przechwytywania z @gbk. **

Dla tych, którzy używają [słabe ja] na liście przechwytywania, zauważ, że self może być zerowe, więc pierwszą rzeczą, którą robię, jest sprawdzenie tego za pomocą oświadczenia strażnika

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

Jeśli zastanawiasz się, czym są cudzysłowy, selfto profesjonalna sztuczka polegająca na użyciu self w zamknięciu bez konieczności zmiany nazwy na to , słabySelf lub cokolwiek innego.

Użyj listy przechwytywania

Definiowanie listy przechwytywania

Każda pozycja na liście przechwytywania jest parą słowa kluczowego o słabym lub nieposiadanym imieniu z odniesieniem do instancji klasy (takiej jak self) lub zmiennej zainicjowanej pewną wartością (na przykład delegate = self.delegate!). Te pary są zapisywane w nawiasach kwadratowych oddzielonych przecinkami.

Umieść listę przechwytywania przed listą parametrów zamknięcia i typem zwracania, jeśli są podane:

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

Jeśli zamknięcie nie określa listy parametrów ani typu zwracanego, ponieważ można je wywnioskować z kontekstu, należy umieścić listę przechwytywania na samym początku zamknięcia, a następnie słowo kluczowe in:

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

dodatkowe wyjaśnienia

EDYCJA: odniesienie do zaktualizowanego rozwiązania firmy LightMan

Zobacz rozwiązanie LightMan . Do tej pory korzystałem z:

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

Lub:

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

Zwykle nie trzeba określać typu parametru, jeśli jest on wywnioskowany.

Możesz całkowicie pominąć parametr, jeśli go nie ma lub jeśli odnosisz się do niego jak $0w zamknięciu:

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

Tylko dla kompletności; jeśli przekazujesz zamknięcie do funkcji, a parametr nie jest @escaping, nie potrzebujesz weak self:

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

Od Swifta 4,2 możemy:

_ = { [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/propiments/0079-upgrade-self-from-weak-to-strong.md

Możesz użyć [słabe ja] lub [nieposiadane własne] na liście przechwytywania przed parametrami bloku. Lista przechwytywania ma opcjonalną składnię.

[unowned self]działa dobrze, ponieważ komórka nigdy nie będzie zerowa. W przeciwnym razie możesz użyć[weak self]

Jeśli masz awarię, niż prawdopodobnie potrzebujesz [słabe ja]

Domyślam się, że blok, który tworzysz, jest nadal w jakiś sposób podłączony.

Utwórz przygotowanieForReuse i spróbuj wyczyścić znajdujący się w nim blok onTextViewEditClosure.

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

Sprawdź, czy to zapobiega awarii. (To tylko przypuszczenie).

Zamknięcie i silne cykle referencyjne ^[Informacje]

Jak wiesz, zamknięcie Swifta może uchwycić instancję. Oznacza to, że możesz używać selfwewnątrz zapięcia. Szczególnie escaping closure^[About] może utworzyć strong reference cyclektóry. Nawiasem mówiąc, musisz jawnie używać w selfśrodku escaping closure.

Szybkie zamknięcie ma Capture Listfunkcję, która pozwala uniknąć takiej sytuacji i przerwać cykl odniesienia, ponieważ nie ma silnego odniesienia do przechwyconej instancji. Element Capture List jest parą weak/ unownedi odniesieniem do klasy lub zmiennej.

Na przykład

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- bardziej preferowane, używaj go, gdy jest to możliwe
• unowned - używaj go, gdy masz pewność, że czas życia właściciela instancji jest dłuższy niż zamknięcie