2

我正在尝试做这件看似微不足道的事情：

static func list() -> Promise<[Activity]> {
    let endpoint = "\(self.baseUrl)/v1/activities"

    return Promise { fulfill, reject in
        self.fetchHeaders { (headers) in
            return Alamofire.request(
                endpoint,
                method: .get,
                parameters: nil,
                encoding: JSONEncoding.default,
                headers: headers
            ).validate().responseJSON().then() { response in
                guard let json = response as? JSON else {
                    reject(ActivityError.parse("Malformed JSON"))
                }

                guard let jsonActivities = json["activities"] as? [JSON] else {
                    reject(ActivityError.parse("Missing field"))
                }

                var activities: [Activity] = []

                for jsonActivity in jsonActivities {
                    guard let activity = Activity(json: jsonActivity) else {
                        reject(ActivityError.parse("Unable to parse an Activity object"))
                    }

                    activities.append(activity)
                }

                fulfill(activities)
            }.catch { error in
                reject(ActivityError.network("HTTP response failure"))
            }
        }
    }
}

但是，编译器（正确地）抱怨说：

'guard' body 可能不会掉下来，考虑使用 'return' 或 'break' 退出范围

我知道我需要在这里返回一个 Promise。我只是不知道在 reject() 和 fully() 调用下面到底要放什么。

4

1 回答 1

7

reject打电话没什么问题fulfill。问题是在reject你的guard声明之后，你还必须return退出关闭：

guard let json = response as? JSON else {
    reject(ActivityError.parse("Malformed JSON"))
    return
}

guard let jsonActivities = json["activities"] as? [JSON] else {
    reject(ActivityError.parse("Missing field"))
    return
}

关键点是您不想将此方法返回的承诺（稍后由fulfillor满足reject）与在此闭包中必须立即使用子句return中的a 退出闭包的事实混为一谈。guard

我无法用您的代码重现此问题（因为您尚未提供MCVE，并且此处有一些我无法解决的参考资料）。但这里是您的代码的简化版本，说明了如何使用guard：

所以，如果不使用 PromiseKit/Alamofire，你可以这样做：

func list() -> Promise<[String: Any]> {
    return Promise { fulfill, reject in
        Alamofire.request(url)
            .validate()
            .responseJSON { response in
                switch response.result {
                case .success(let json):
                    guard let dictionary = json as? [String: Any] else {
                        reject(ActivityError.malformed("not a dictionary"))
                        return
                    }
                    fulfill(dictionary)
                case .failure(let error):
                    reject(error)
                }
        }
    }
}

如您所见，您正在返回一个Promise，但在 Alamofire 闭包中，您只是退出了您的guard语句。

如果您使用 PromiseKit/Alamofire 和 call then，您可能想要创建一个可以返回的承诺，例如：

func list() -> Promise<String> {
    return Alamofire.request(endPoint)
        .validate()
        .responseJSON()
        .then { value in
            return Promise { fulfill, reject in
                guard let dictionary = value as? [String: Any], let name = dictionary["name"] as? String else {
                    reject(ActivityError.malformed("not dictionary"))
                    return
                }

                fulfill(name)
            }
    }
}

或者，如果这太麻烦，您可以提取以下解析value：

func list() -> Promise<String> {
    return Alamofire.request(endPoint)
        .validate()
        .responseJSON()
        .then { value in
            self.parse(value)
    }
}

func parse(_ value: Any) -> Promise<String> {
    return Promise { fulfill, reject in
        guard let dictionary = value as? [String: Any], let name = dictionary["name"] as? String else {
            reject(ActivityError.malformed("not dictionary"))
            return
        }

        fulfill(name)
    }
}

但是，无论哪种方式，即使使用 PromiseKit/Alamofire，您仍然只是return在该guard子句中。

于 2016-11-16T18:03:51.187 回答