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

Question

我正在慢慢了解完成处理程序。 如果我有一个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()

                        }
                    }
                }

            }

谢谢。

更新

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

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.

我想要发生的是编程在继续执行之前等待完成（）。

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

谢谢

Answer 1

这里是完整的例子（使用 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