0

我正在尝试使用PromiseKit来驯服一些厄运代码的回调地狱金字塔。

为此，我将异步代码包装在 Promise 中，但根据我返回依赖 Promise 的方式，我会遇到问题。如果我打开承诺并履行/拒绝，那么一切都很好，尽管比我想要的更冗长。如果我返回一个新的依赖承诺，那么我会得到一个早期的分配并且承诺会被默默地破坏。

我意识到这可能不是惯用的 PromiseKit，它似乎是

{ a }.then { b }.then { c }  // in temporal order, take that, callbacks!

但作为这项工作的一部分，我用函数重构很方便，Promise<A> -> Promise<B>我不明白为什么我必须在每一步都打开包装。有人知道吗？

这是一些重现问题的简化代码。试着想象有一个很好的理由badStringFromInt不能立即实现。

func badStringFromInt(_ intPromise: Promise<Int>) -> Promise<String> {
    return Promise { _, reject in
        intPromise.then { i -> Promise<String> in
            return Promise { fulfill, _ in
                fulfill("\(i)")
            }
        }.catch { error in
            reject(error)
        }
    }
}

func goodStringFromInt(_ intPromise: Promise<Int>) -> Promise<String> {
    return Promise { fulfill, reject in
        intPromise.then { i in
            fulfill("\(i)")
        }.catch { error in
            reject(error)
        }
    }
}

func getInt() -> Promise<Int> {
    return Promise{ fulfill, reject in
        fulfill(5)
    }
}

func doIt() {
    // "then" never called, and this is logged:
    // PromiseKit: Pending Promise deallocated! This is usually a bug
    badStringFromInt(getInt()).then { s in
        print("bad string is :" + s)
    }.catch { error in
        print("error: \(error)")
    }

    // all good!
    goodStringFromInt(getInt()).then { s in
        print("good string is :" + s)
    }.catch { error in
        print("error: \(error)")
    }
}
4

1 回答 1

1

我肯定错过了什么。为什么不直接添加到链上？创建中间承诺对你有什么作用？

betterStringFromInt等待intPromise完成，然后返回一个字符串承诺。

func betterStringFromInt(_ intPromise: Promise<Int>) -> Promise<String> {
    return intPromise.then { i in
        DispatchQueue.main.promise {
            return "\(i)"
        }
    }
}
于 2017-04-18T03:18:59.360 回答