Question

我正试图做这个看似微不足道的事情：

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"))
            }
        }
    }
}

然而，编译器（理所当然地）抱怨：

'后卫'身体可能无法通过，考虑使用'返回'或'休息' 退出范围

我知道我需要在这里返回承诺。我只是无法弄清楚究竟要放在reject（）和fulfill（）调用之下。

Answer 1

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
}

关键是你不想混淆这个方法返回的promise（稍后由fulfill或reject满足），事实上在这个闭包中，你必须使用return子句中的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并致电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。

从PromiseKit / Alamofire回复承诺

1 个答案: