我刚开始使用 Swift 进行开发，所以我对闭包完全陌生。我还不知道如何处理异步 API 请求。

我读过很多类似的问题，例如 How to get data to return from NSURLSessionDataTask in Swift和 How to use completionHandler Closure with return in Swift? .这些对我有帮助，但我的问题有点不同。

在我的函数中，我想首先发出 API 请求以获取 JSON 负载。有了这个 JSON 负载中的一些数据，我想发出多个其他 API 请求。在这种情况下，我将为每个 API 请求接收一个 JSON 负载，我想在其中将一些数据存储在我自己的 JSON 数据结构中。

问题是，对于我发出的每个多个 API 请求，我只能在我的 CompletionHandler 中返回我自己的 JSON 数据的一部分——据我所知，这是使用闭包发出 API 请求时返回数据的唯一方法.

因此，在调用我的函数时，我不想获得多个完成处理程序，而是只想接收一个。

问题是我不知道如何完成处理一个函数中的多个闭包，在本例中是两个闭包。

我已经在下面发布了我的代码 - 我知道它很长而且可能不是那么干净。 然而，要点是，当我更新我的 storeDict 报价时，这将是空的，因为报价字典数组是从第二个闭包内部获取信息的。这显示在函数的底部。

   func getOffersFromWishList(offerWishList: [String], latitude: Double, longitude: Double, radius: Int, completionHandler: ([NSDictionary] -> Void)) {

        var master: [NSDictionary] = []

        var nearby_params: NSDictionary = ["r_lat": latitude, "r_lng": longitude, "r_radius": radius]
        //println(nearby_params)
        var store_id_list: [String] = []


        // Get all store_ids for store which are nearby (Radius determines how nearby)
        singleton_eta.api("/v2/stores", type: ETARequestTypeGET, parameters: nearby_params, useCache: true, completion: { (response, error, fromCache) -> Void in

            if error == nil {

                let json = JSON(response)
                storeArray = json.arrayValue
                //println(storeArray)

                for store in storeArray {

                    var storeDict = [String: AnyObject]()
                    var metaData = [String: String]()
                    var offers: [NSDictionary] = []

                    let name = store["branding"]["name"].stringValue
                    let store_id = store["id"].stringValue
                    let street = store["street"].stringValue
                    let city = store["city"].stringValue
                    let zip_code = store["zip_code"].stringValue
                    let dealer_id = store["dealer_id"].stringValue
                    let logo = store["branding"]["logo"].stringValue

                    metaData = ["name": name, "store_id": store_id, "street": street, "city": city, "zip_code": zip_code, "dealer_id": dealer_id, "logo": logo]

                    store_id_list.append(store_id)

                    //println("Butiks ID: \(store_id)")

                    var offset = 0
                    let limit = 100

                    // Loop through the offers for the specific store id - only possible to request 100 offers each time
                    // A while loop would be more suitable, but I dont know when to stop, as the length of the offerArray can not be counted as it is cant be accessed outside of the closure.
                    for x in 1...2 {

                        var store_params: NSDictionary = ["store_ids:": store_id, "limit": limit, "offset": offset]
                        println(store_params)
                        // Get offers for a specific store_id
                        singleton_eta.api("/v2/offers", type: ETARequestTypeGET, parameters: store_params, useCache: true, completion: { (response, error, fromCache) -> Void in

                            if error == nil {

                                offerArray = JSON(response).arrayValue
                                //println( "TypeName0 = \(_stdlib_getTypeName(offerArray))")

                                //Loop through the recieved offers
                                for of in offerArray {

                                    let name = of["branding"]["name"].stringValue
                                    let dealer_id = of["dealer_id"].stringValue
                                    let heading = of["heading"].stringValue
                                    let description = of["description"].stringValue
                                    let price = of["pricing"]["price"].stringValue
                                    let image = of["images"]["view"].stringValue


                                    //println(heading)

                                    // Loop through our offerWishList
                                    for owl in offerWishList {

                                        let headingContainsWish = (heading.lowercaseString as NSString).containsString(owl.lowercaseString)

                                        // Check if offer match with our wish list
                                        if(headingContainsWish) {

                                            // Save neccesary meta data about each offer to a tuple array
                                            var offer = Dictionary<String, String>()
                                            offer = ["name": name, "dealer_id": dealer_id, "heading": heading, "description": description, "price": price, "image": image, "offerWishItem": owl]

                                            offers.append(offer)


                                        }

                                    }

                                }


                            }

                        })
                        //println(storeDict)
                        offset = offset + limit + 1

                    }

                    storeDict.updateValue(metaData, forKey: "meta_data")
                    storeDict.updateValue(offers, forKey: "offers")  // offers is empty due to its appending inside the closure
                    master.append(storeDict)

                }
             completionHandler(master)

            }

            else {
                println(error)
            }


        })

    }

调用上面的函数

getOffersFromWishList(offerWishList, latitude, longitude, radius) { (master) -> Void in
       println(master)
    }

这是master在调用函数时打印的内容，其中offers为空。

{
"meta_data" =     {
    city = "Kongens Lyngby";
    "dealer_id" = d8adog;
    logo = "https://d3ikkoqs9ddhdl.cloudfront.net/img/logo/default/d8adog_3qvn3g8xp.png";
    name = "d\U00f8gnNetto";
    "store_id" = d2283Zm;
    street = "Kollegiebakken 7";
    "zip_code" = 2800;
};
offers =     (
);
}
{ 
  ...
}

所以我的问题是，在函数内将数据从第二个闭包返回到第一个闭包的正确方法是什么？还是我以完全错误的方式这样做？ 问题是，我需要一个 TableView 的所有这些数据，因此一次需要所有数据。

最佳答案

几个想法:

1. 如果有任何可能在对服务器的单个请求中返回所有这些，那可能会提供更好的性能。通常，与网络延迟相比，在服务器上执行请求所需的时间是无关紧要的。如果您可以避免需要发出一个请求、获得响应，然后再发出更多请求，那将是理想的。

   或者您可能提前请求一定距离内的位置，将其缓存，然后“显示附近位置的交易”可能不需要这两组请求。

   (我知道这些可能都不适合您，但如果可以的话，您可以考虑一下。如果您可以消除连续请求并专注于大量并发请求，您将获得更好的性能。)

2. 让我们暂时假设以上不是一个选项，并且您遇到了一个获取附近位置的请求和另一个获取交易的请求。然后你有几个选择:

   • 您绝对可以通过一次回调沿着您正在考虑的道路前进。例如，您可以发出所有请求，执行 dispatch_group_enter在你发起每个请求之前，做一个 dispatch_group_leave在每个请求完成后，然后发出 dispatch_group_notify这将在每个 enter 时被调用调用已被相应的 leave 抵消称呼。因此，在每个请求完成时构建您的响应对象，并且只有在它们完成时才调用完成闭包。

   • 另一种方法是使用一个行为更像枚举闭包的闭包，在每个站点的交易进入时调用一个闭包。这样，UI 可以在进入时更新，而不是等待一切。如果您的网络速度较慢，则在数据传入时更新 UI 可能更容易接受。 (例如，考虑 10 个请求，每个请求在慢速 3G 蜂窝连接上需要 1 秒完成:看着它们每秒弹出一个比 10 秒什么都看不到要容易得多)。

   • 话虽如此，您可能想要完全放弃闭包。你可以考虑 delegate - protocol模式，您可以在其中指定 delegate根据您的要求，然后实现 protocol您从服务器获得的每个响应的方法。这样您就可以在收到新响应时更新 UI，而不是将所有内容都保留到最后一个响应为止。但是我们认识到存在非常不同类型的响应(一种是站点列表，另一种是列表对于给定站点的交易，第三个将是“我已经完成”和/或“出现错误”)，因此当它开始变得如此复杂时，最好为此接口(interface)定义一个协议(protocol)，并且那样处理。

关于api - swift 中具有多个闭包/API 请求的函数中的异步完成处理，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29521672/