Swift 理解可逃逸闭包

有人能通过下面的示例（代码流）帮助我理解可转义闭包吗

它是这样使用的（来自测试用例的片段）

提前谢谢

还有，中的

userInfoError在这里是什么意思

更新：所以我很想了解流程，比如什么叫什么，什么时候

比如说，在上面的代码片段中

something.newTask（请求：userInfoRequest，completionHandler:{

我们通过，
userInfoRequest
和
completionHandler:{

另外，上面completionHandler的类型是什么？在JS中，我们声明了一个类似于
completionHandler:{

我假设对于
closure
这就是我们传递函数然后它处理代码的方式。在完成处理程序中

我的理解是，我们将
completionHandler
传递给
static func newTask
completionHandler
在这里只是一个函数，用于向上发送事件到调用函数（
public static func newTask
），以便在处理public static func newTask之后执行

当我们执行
completionHandler（nil，nil，xyz（“在调用某物.newTask之前应该调用something.xyz”）
时，我们将
userInfoData、userInfoResponse、userInfoError
作为
nil，nil-xyz（“在调用某物.newTask之前应该调用something.xyz”）

我不知道这有多大意义

什么叫什么以及什么时候

首先，调用
something.newTask
，因此执行此块：

if !something.xyz {
    completionHandler(nil, nil, xyz("something.xyz should be called before calling something.newTask"))
    return
}
readWriteDispatchQueue.async {
    makeRequest(request: request, completionHandler: completionHandler)
}

如果它进入
If
语句，则
completionHandler
，在本例中，它是传递给
newTask
的
{…}
中的所有内容，将在那里使用指定参数进行调用

否则，
readWriteDispatchQueue.async
被调用，而
newTask
返回。在
newTask
返回后很短的时间内（因为这是“async”），
makeRequest
被调用并返回。在
makeRequest
完成它正在做的事情后（可能是在它收到响应时？），
completionHandler
被调用

另外，上面的completionHandler的类型是什么

它的类型写在方法签名
（Data？、urresponse？、Error？->Void
，读作“接受
数据的闭包”
、
urresponse？
和
错误？
，并且不返回任何内容”

我假设对于闭包，这就是我们传递函数然后它处理代码的方式

正确。在Swift中，闭包由
{…}
表示。有关闭包语法的更多信息，请阅读

我的理解是我们将completionHandler传递给静态func newTask。completionHandler只是一个函数，用于向上向调用函数（公共静态func newTask）发送事件，以便在处理公共静态func newTask后执行

虽然措辞有点不标准，但我想你明白了

当我们执行completionHandler（nil，nil，xyz（“在调用something.newTask之前应该调用something.xyz”））时，我们将userInfoData，userInfoResponse，userInfoError作为nil，nil-xyz（“在调用something.newTask之前应该调用something.xyz”）传递给completionHandler

我想说的是，我们正在将
nil，nil，xyz（“在调用某物.newTask之前应该调用某物.xyz”）
传递给
completionHandler
，而不是反过来。
Hey@Sweeper，你太棒了。这回答了我的问题。只是另一个问题（可能与上述代码无关）。如果userInfoError！=nil，这一行的意思是什么{

像上面语法中的

一样吗？谢谢again@anny123请记住，闭包基本上是函数。
userInfoData、userInfoResponse、userInfoError
是函数的三个参数。

中的

一词只是用作分隔参数和主体的分隔符。它有点类似于中的
=>
一个javascript lambda。
something.newTask(request: userInfoRequest, completionHandler: {
                userInfoData, userInfoResponse, userInfoError in

                if userInfoError != nil {
                    failureMessage = "userInfo API error"
                    requestSemaphore.signal()
                    return
                }

                if userInfoResponse as? HTTPURLResponse != nil {
                    let userInfoHttpResponse = userInfoResponse as! HTTPURLResponse
                    if userInfoHttpResponse.statusCode != 200 {
                        failureMessage = "failed"
                    }
                    let idAfter = IdRefreshToken.getToken()
                    if idAfter == idBefore {
                        failureMessage = "failed"
                    }
                    requestSemaphore.signal()
                } else {
                    failureMessage = "failed"
                    requestSemaphore.signal()
                }
            })

if !something.xyz {
    completionHandler(nil, nil, xyz("something.xyz should be called before calling something.newTask"))
    return
}
readWriteDispatchQueue.async {
    makeRequest(request: request, completionHandler: completionHandler)
}