Question

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

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

我意识到这可能不是惯用的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)")
    }
}

Answer 1

我一定错过了什么。为什么不加入链？什么创造中间承诺为你做什么？

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

func betterStringFromInt(_ intPromise: Promise<Int>) -> Promise<String> {
    return intPromise.then { i in
        DispatchQueue.main.promise {
            return "\(i)"
        }
    }
}

PromiseKit依赖的承诺导致早期解除分配

1 个答案: