如何撤销承诺？

Posted 2023-02-24

【中文标题】如何撤销承诺？

【英文标题】：How do I reverse a promise?

【发布时间】：2019-08-02 15:42:17

【问题描述】：

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

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

所以我像在之前的应用程序中一样，在组合中添加了一个后退按钮。唯一的问题是，如果你想这样称呼它，我不确定如何处理“倒车”。

所以说我有流量

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

假设我当时处于链条的第一或第二部分，我想回到链条的上游 - 这可能吗？

有没有你们可以给我的链接，我可以用来阅读如何做到这一点？

我在想我可能必须重新启动“链”，但是我将如何逐步完成流程....等待（灯泡），我可以用最初的数据以编程方式履行必要的承诺直到我到达需要返回的“链”中的点，对吧？

建议 D：？

【问题讨论】：

您所描述的似乎不可能。你有一个你想要实现的行为的具体例子吗？

你总是可以随心所欲地扔和抓。

通过保存对 Promise 的引用，您始终可以触发不同的事件链。在下面写了一个例子作为我的答案。

您尝试实现的目标的示例对我们帮助您解决此问题非常有帮助。

【参考方案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

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

【参考方案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

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

【参考方案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(())