相关疑难解决方法(0)

我需要在内心深处保持坚强的自我。我知道[weak self]对于外部封闭来说只声明一次就足够了。

但是guard let self = self else { return }，对于外部封闭也声明一次就足够了吗？我们这里有什么边缘情况吗？

  apiManager.doSomething(user: user) { [weak self] result in
            guard let self = self else { return }

            self.storageManager.doSomething(user: user) { result in
                // guard let self = self else { return } <- DO WE NEED IT HERE ?
                self.doSomething()
            }
        }

似乎语言分析器说“没有一个声明就足够了”，但想确定一下。

如果我有一个闭包传递给这样的函数:

 someFunctionWithTrailingClosure { [weak self] in
     anotherFunctionWithTrailingClosure { [weak self] in 
         self?.doSomething()
     }
 }

如果我[weak self]在someFunctionWithTrailingClosure自己的捕获列表中声明自己没有重新声明它weak再次在捕获列表中anotherFunctionWithTrailingClosure self已经成为一种Optional类型但是它也成为一个weak参考？

谢谢!

经过一些研究，我发现我的应用程序使用了太多的能量，因为UIView整个应用程序中有几个动画，我在完成块中捕获了相关的动画UIViewController，而没有对其进行弱引用。

所以实际上，我改变了这一点：

func animate() {
    UIView.animate(withDuration: 0.3, animations: {
        self.label.alpha = 0.5
    }) { _ in 
        self.animate()
    }
}

进入这个：

func animate() {
    UIView.animate(withDuration: 0.3, animations: {
        self.label.alpha = 0.5
    }) { [weak self] _ in 
        self?.animate()
    }
}

但是，我想知道我是否需要对animation块（self.label.alpha = 0.5那个）做同样的事情？

感谢您的帮助

在Swift中，当使用时[weak self] in，当嵌套在另一个闭包中时，我应该加倍使用。

例：

override func viewDidLoad() {
    super.viewDidLoad()

    makeAPICall() { [weak self] in

        self?.finishedAPICall = true

        DispatchQueue.main.async { [weak self] in
            // random code with self
            self?.view.layoutIfNeeded()
        }
    }
}

func makeAPICall(completion: () -> Void) {}

最外层[weak self]使得以下所有自我都是可选的。这是否意味着它也一直在将其保存在嵌套闭包内部的内存中？如果我在两个方面都使用自我，是否在两个方面都需要自我？

我觉得我一直误解了何时创建引用循环。在我过去认为几乎任何你有一个块并且编译器强迫你写的地方之前，.self这表明我正在创建一个引用循环，我需要使用[weak self] in.

但以下设置不会创建参考循环。

import Foundation
import PlaygroundSupport

PlaygroundPage.current.needsIndefiniteExecution


class UsingQueue {
    var property : Int  = 5
    var queue : DispatchQueue? = DispatchQueue(label: "myQueue")

    func enqueue3() {
        print("enqueued")
        queue?.asyncAfter(deadline: .now() + 3) {
            print(self.property)
        }
    }

    deinit {
        print("UsingQueue deinited")
    }
}

var u : UsingQueue? = UsingQueue()
u?.enqueue3()
u = nil

该块仅保留self3 秒。然后释放它。如果我使用async而不是asyncAfter那么它几乎是立即的。

据我了解，这里的设置是：

self ---> queue
self <--- block

队列只是块的外壳/包装器。这就是为什么即使我nil排队，块也会继续执行。他们是独立的。

那么是否有任何设置只使用队列并创建参考循环？

据我所知[weak self]，仅用于引用循环以外的其他原因，即 …