如何使用完成处理程序等待 firestore 请求的完成

我正在慢慢地了解完成处理程序。 如果我有一个 firestore 查询，如果我想使用完成处理程序，则有点向后工作，当 firestore 查询完成时，我必须使用completion() 。

但它的设置功能仍然让我感到困惑。

因此，如果这是一个将闭包作为参数的函数定义：

  func doSomethingAsync(completion: () -> ()) {
  }

我不太明白如何从上面的 func 定义出发并实现它来实现像 firestore 查询和请求这样的真实内容。

 query.getDocuments(){ (querySnapshot, err) in

                if let err = err
                {
                    print("Error getting documents: \(err)")
                }
                else
                {
                    if(querySnapshot?.isEmpty)!
                    {


                        print("there's no document")
                        completion()


                    }
                    else
                    {
                        for document in querySnapshot!.documents
                        {

                            completion()

                        }
                    }
                }

            }

thanks.

update

所以对于我的例子我可以做类似的事情

func getFirestoreData(userID: String, completion @escaping() -> ()){

//firestore code:

query.getDocuments(){ (querySnapshot, err) in

                    if let err = err
                    {
                        print("executed first")
                        completion()
                    }
                    else
                  .......
                    print("executed first")
                    completion()

       }
}

调用我正在执行的函数：

getFirestoreData(userID: theUserID) {

            print("executes second")

        }

print("executes third") after function execution.

我希望发生的是编程在继续执行之前等待completion()。

但是“执行第三个”首先发生，然后“执行第一个”，然后“执行第二个”。

Thanks

这是完整的示例（带 API 调用） 请注意：状态变量只是找出服务器响应内容的关键 （0：来自服务器的错误，1：成功，-1：我的代码中有问题）

 func logout(handlerBack: @escaping (_ error: Error?, _ status:Int?, _ error_message:String?)->())
{

    Alamofire.request(url, method: .get, parameters: nil, encoding: JSONEncoding.default, headers: nil)
        .responseJSON { respons in
            switch respons.result {
            case .failure(let theError):
                handlerBack(theError, 0, nil)

            case .success(let data):
                let json_data = JSON(data)

                /// if couldn't fetch data
                guard let status = json_data["status"].int else {
                    handlerBack(nil,-1, "can't find status")
                    return
                }

                /// if statuse == 0
                    guard status == 1 else {
                        handlerBack (nil, 0 , json_data["errorDetails"].string)
                        return
                    }

                // that's means everything fine :)
                    handlerBack(nil, 1 , nil)
                }
        }
    }

这是实现它的方法：

        // call func 
  self.logout { (error:error, status:Int, error_message:String) in
            // if status not 1, figure out the error 
        guard status == 1 else {
            // try to find error from server
            guard let error_message = error_message else {
            // else error something else 
                print ("Error at :: \(#function)")
                // don't do anything ..just return 
                return
            }
            self.showMessageToUser(title: error_message, message: "", ch: {})
            return
        }
                   // this part do what ever you want, means every thing allright 
    }

更新 ： 您正在寻找等待单元执行“第一”和“第二”的东西

在这种情况下使用DispatchGroup()这是例子：

            var _dispatch_group = DispatchGroup()

        getFirestoreData(userID: theUserID) {

            _dispatch_group.enter()
            print("executes second")


            _dispatch_group.leave()

        }

        _dispatch_group.notify(queue: .main) {
        print("executes third")
        }

输出是：

executes First
executes Second
executes Third