Muss man immer weak oder unowned in der Capture-Liste…

Nein, nicht immer.

Weak und unowned werden verwendet, um starke Referenzzyklen (retain cycles) in Closures zu verhindern, wenn die Closure eine starke Referenz auf ein Objekt hält und das Objekt wiederum eine starke Referenz auf die Closure hält.

Es ist notwendig, weak oder unowned zu verwenden, wenn die Closure eine starke Referenz auf self oder einen anderen referenziellen Typ erfasst und die Wahrscheinlichkeit eines Zyklus besteht.

Situationen, in denen weak/unowned nicht notwendig sind:

Die Closure erfasst Werttypen (Strukturen, Aufzählungen, Tupel). Diese werden beim Erfassen kopiert, und es entstehen keine starken Referenzzyklen.
Die Closure erfasst einen referenziellen Typ, aber es besteht kein bidirektionaler starker Referenzzyklus. Zum Beispiel, wenn die Closure lokal innerhalb einer Methode erstellt wird und nicht in einem Objekt gespeichert wird, auf das sie verweist.
Die Closure hat eine kurze Lebensdauer und wird ausgeführt, bevor das Objekt, auf das sie verweist, freigegeben wird. Zum Beispiel, eine Closure, die als Completion Handler an eine Methode übergeben wird und sofort ausgeführt wird.

Auswahl zwischen weak und unowned:

weak: Wird verwendet, wenn das erfasste Objekt jederzeit nil werden kann, bevor die Closure ausgeführt wird. Die Referenz ist optional (ObjectType?). Es ist eine nil-Prüfung vor der Verwendung erforderlich.
unowned: Wird verwendet, wenn bekannt ist, dass das erfasste Objekt immer zum Zeitpunkt der Ausführung der Closure existiert. Die Referenz ist nicht optional (ObjectType). Es ist keine nil-Prüfung erforderlich. Die Verwendung von unowned für ein nil-Objekt führt zu einem Laufzeitfehler.

// Beispiel, bei dem `weak`/`unowned` nicht notwendig sind (Werttyp-Erfassung)
struct MyStruct {
    var value: Int
}

let myStruct = MyStruct(value: 10)
let closure = {
    print(myStruct.value) // Erfasst eine Kopie von myStruct
}
closure()

// Beispiel, bei dem `weak`/`unowned` nicht notwendig sind (lokaler Closure)
class MyClass {
    func doSomething() {
        let localValue = 5
        let localClosure = {
            print(self.description) // Erfasst self, aber die Closure wird nicht in MyClass gespeichert
        }
        localClosure()
    }

    var description: String {
        return "Instance of MyClass"
    }
}

let myObject = MyClass()
myObject.doSomething()

// Beispiel, bei dem `weak` notwendig ist (potenziell nil)
class AsyncOperation {
    var completionHandler: (() -> Void)?

    func performOperation() {
        // Simulation asynchroner Arbeit
        DispatchQueue.global().async {
            print("Operation completed")
            self.completionHandler?() // optionale Verkettung
        }
    }

    deinit {
        print("AsyncOperation deinitialized")
    }
}

class ViewController {
    var op: AsyncOperation?

    func setupOperation() {
        op = AsyncOperation()
        op?.completionHandler = { [weak self] in // weak self
            guard let self = self else { return }
            print("Completion handler in ViewController: \(self)")
        }
    }

    deinit {
        print("ViewController deinitialized")
    }
}

// Beispiel, bei dem `unowned` notwendig ist (garantiert vorhanden)
class Button {
    var action: (() -> Void)?

    func tap() {
        action?()
    }

    deinit {
        print("Button deinitialized")
    }
}

class ViewControllerWithButton {
    var button: Button

    init() {
        button = Button()
        button.action = { [unowned self] in // unowned self
            print("Button tapped in ViewControllerWithButton: \(self)")
        }
    }

    deinit {
        print("ViewControllerWithButton deinitialized")
    }
}

Muss man immer weak oder unowned in der Capture-Liste verwenden?