ios - swift promise 套件 : Equivalent to when() which executes sequentially?

Question

我将 PromiseKit 与 Swift 结合使用，到目前为止它非常方便。它们提供的功能之一是 when()，它允许您拥有任意数量的 promise 数组，并且仅在所有 promise 完成后才执行某些操作。

然而，数组中的promise是并行执行的。我还没有找到任何允许我按顺序执行它们的函数。我试图编写自己的递归函数，但它似乎没有按照它们在数组中的顺序执行 promise ，而且我偶尔会遇到“Promise deallocated”错误。请帮忙!

static func executeSequentially(promises: [Promise<Void>]) -> Promise<Void> {
    return Promise<Void> { fulfil, reject in
        var mutablePromises = promises
        if mutablePromises.count > 0 {
            mutablePromises.first!
                .then { _ -> Promise<Void> in
                    print("DEBUG: \(mutablePromises.count) promises in promise array.")
                    mutablePromises.remove(at: 0)
                    return executeSequentially(promises: mutablePromises)
                }.catch { error in
                    print("DEBUG: Promise chain rejected.")
                    reject(error)
            }
        } else {
            print("DEBUG: Promise chain fulfilled.")
            fulfil(())
        }
    }
}

Answer 1

这是一个扩展，它接受一组 promise 并返回一个新的 promise ，其中所有单独的 promise 链接在一起以串行运行。我修改了此处找到的版本以与 Swift 5/PromiseKit 7 alpha 一起使用:https://gist.github.com/kashifshaikh/416b9ffbd300eb680fad3641b6ec53ea

可以在此处找到原作者的随附帖子:https://medium.com/@peatiscoding/promisekit-chaining-3c957a8ace24

import Foundation
import PromiseKit

extension Promise {
  
  /// Returns a single Promise that you can chain to. Wraps the chains of promises passed into the array into a serial promise to execute one after another using `promise1.then { promise2 }.then ...`
  ///
  /// - Parameter promisesToExecuteSerially: promises to stitch together with `.then` and execute serially
  /// - Returns: returns an array of results from all promises
  public static func chainSerially<T>(_ promises:[() -> Promise<T>]) -> Promise<[T]> {
    // Return a single promise that is fulfilled when
    // all passed promises in the array are fulfilled serially
    return Promise<[T]> { seal in
      var outResults = [T]()
      
      if promises.count == 0 {
        seal.fulfill(outResults)
      } else {
        let finalPromise:Promise<T>? = promises.reduce(nil) { (r, n) -> Promise<T> in
          return r?.then { promiseResult -> Promise<T> in
            outResults.append(promiseResult)
            return n()
          } ?? n()
        }
        
        finalPromise?.done { result in
          outResults.append(result)
          
          seal.fulfill(outResults)
        }.catch { error in
          seal.reject(error)
        }
      }
    }
  }
}

用法:

let serialSavePromises: [() -> Promise<Bool>] = allImages.map { image in
 return { [weak self] in
   guard let self = self else { return .value(false) }
      
   return self.saveImage(image)
 }
}
            
return Promise<[Bool]>.chainSerially(serialSavePromises)