Question

我正在使用PromiseKit处理流程中的流程。

之前，我做了一个没有承诺的类似应用程序，但决定decided之以鼻，我将尝试承诺只是因为，好吧，为什么不呢？

因此，就像在上一个应用程序中一样，我在混合中添加了后退按钮。唯一的问题是，如果您要称呼它，我不确定如何处理“反向”。

所以说我有一个

doSomething().then {
    // do something else 
}.then { 
    // do something else 
}.done { 
    // wrap it up, boss
}.catch { 
   // you're an idiot, bud 
}

说我在链的第一部分或第二部分中，然后我想回到链的顶部-这可能吗？

你们是否都可以给我链接，我可以用来阅读如何做？

我正在考虑可能必须重新启动“链”，但是那我将如何逐步完成流程。...WAIT（灯泡），无论最初的数据是什么，我都可以通过编程方式履行必要的承诺直到我到达“链”中需要回到的位置，对吧？

建议D：？

Answer 1

您始终可以在同一诺言上拥有catch和then。

var somePromise = doSomething()

// first chain
somePromise.catch { error in 
    // handle error 
}

// second chain from the same starting point
somePromise.then { 
    // do something else
}.then { 
   // do something else 
}.catch {
    // you can still catch the error here too
}

您基本上是从同一原始诺言创建两个诺言链。

Answer 2

不，您不能这样做。提交promise后，您将无法撤消该操作。由于该链应该按降序完成，因此在每个.then块中跟踪顺序比较麻烦。

您可以做的是，处理负责fulfill或reject promise的内部逻辑，并从头开始创建链。

func executeChain() {

    doSomething().then {
        // do something else 
    }.then { 
        // do something else 
    }.done { 
        // condition to 
        executeChain()
    }.catch { 
        // you're an idiot, bud 
    }
}

func doSomething() -> Promise<SomeThing>{

    if (condition to bypass for reversing) {
        return .value(something)
    }

    // Normal execution
}

但是，如果您可以通过实际的用例和代码来改善问题，那么它可以帮助提供更合适的解释。

Answer 3

不，你不能，但是你可以在数组中设置顺序。

bar(promises: [foo1(), foo2(), foo3()])


func bar<T>(promises: [Promise<T>]) {

    when(fulfilled: promises)
    .done { _ in
        // TODO
    }
    .catch { error in
        // When get error reverse array and call it again
        self.bar(promises: promises.reversed())
    }

}

func foo1() -> Promise<Void> {
    return Promise { $0.fulfill(()) }
}

func foo2() -> Promise<Void> {
    return Promise { $0.fulfill(()) }
}

func foo3() -> Promise<Void> {
    return Promise { $0.fulfill(()) }
}

或者

    bar(foo1, foo2, foo3)
    .done { _ in
        // TODO
    }
    .catch { error in
        print(error.localizedDescription)

        self.bar(self.foo3, self.foo2, self.foo1)
        .done { _ in
            // TODO
        }
        .catch { error2 in
            print(error2.localizedDescription)
        }
    }


    func bar<T>(_ promise1: () -> Promise<T>,
                _ promise2: @escaping () -> Promise<T>,
                _ promise3: @escaping () -> Promise<T>) -> Promise<T> {

        return Promise { seal in
            promise1()
            .then { _ in return promise2() }
            .then { _ in return promise3() }
            .done { model in
                seal.fulfill(model)
            }
            .catch {
                seal.reject($0)
            }
        }

    }

    func foo1() -> Promise<Void> {
        return Promise { $0.fulfill(()) }
    }

    func foo2() -> Promise<Void> {
        return Promise { $0.fulfill(()) }
    }

    func foo3() -> Promise<Void> {
        return Promise { $0.fulfill(()) }
    }

如何兑现承诺？

3 个答案: