本文使用的 Promises 是谷歌最近开源的轻量，高性能，安全，测试完备的 Promise 框架。https://github.com/google/promises

Swift 关于 Promise 的优秀框架还有 PromiseKit 和 BrightFutures。

什么是Futures & Promises?

Future 和 Promise 其实是一个东西。很多iOS开发者可能没有听说过 Promise。Promise 在 JavaScript 中最为活跃。JavaScript 中大部分代码都是单线程的，在没有引入 Promise 时，开发者一般编写回调函数，但在某些特殊的情况下回调嵌套非常的多，代码就会变得非常难读，难以调试。在 iOS 中，Swift 闭包 closure 反复嵌套闭包（OC 代码块 block 嵌套代码块）的时候问题也同样严重。通俗的说 Promise 就是链的方式对结果类型闭包的封装，避免层层闭包重复嵌套难以阅读。

简单场景

日常开发中可能会使用这样的网络请求：

• 第三方平台授权获取第三方 key
• 使用 key 登录获取并保存 token
• 使用 token 获取用户信息

facebookAuth() { result in
    switch result {
    case .success(let tokenString, let fbUserID):
        login(tokenString: tokenString, fbUserID: fbUserID) { result in
            switch result {
            case .success(let token):
                loadUserProfile(token: token) { result in
                    saveToken(token: token)
                    switch result {
                    case .success(let user):
                        saveUser(user: user)
                    case .failure(let error):
                        print("---LoadUserProfile--- Error: \(error)")
                    }
                }
            case .failure(let error):
                print("---Login--- Error: \(error)")
            }
        }
    case .failure(let error):
        print("---FBLogin--- Error: \(error)")
    }
}

可以看到即便是将请求方法剥离，使用枚举enum封装了网络请求回调，代码还是一层套一层，显然是陷入了回调地狱。
在使用 Promise 后，代码看起来像是这样

facebookAuth()
 .then { tokenString, fbUserID in
    return login(tokenString: tokenString, fbUserID: fbUserID)
}.then { token in
    saveToken(token: token)
    return loadUserProfile(token: token)
}.then { user in
    saveUser(user: user)
}.catch { error in
    print("---Login Error---: \(error)")
}

上述就是一个 Promise 如何为异步编程中回调地狱提供的帮助例子，可读性和可维护性都变得很高。

概念

Promise 是解决例如在多个线程中并行执行重操作，延迟执行代码这些难以调试、容易中断的问题的解决方案之一。

Promise 可以有三种状态：

pending   - 待定状态，Promise对象刚被初始化的状态
fulfilled - 满足状态（成功情况，可进行例如更新UI操作）
rejected  - 拒绝状态（抛出错误）

一旦是 fulfilled 或 rejected 状态，Promise 不会再改变状态

Promises 使用解析

Pending

let promise = Promise<String>.pending()
// ...
if success {
  promise.fulfill("Hello world")
} else {
  promise.reject(someError)
}

初始化 pending 状态（暂时没有异步操作），随后根据状态完成情况来更新 Promise 状态。

Then

func work1(_ string: String) -> Promise<String> {
  return Promise {
    return string
  }
}

func work2(_ string: String) -> Promise<Int> {
  return Promise {
    return Int(string) ?? 0
  }
}

func work3(_ number: Int) -> Int {
  return number * number
}

work1("10").then { string in
  return work2(string)
}.then { number in
  return work3(number)
}.then { number in
  print(number)  // 100
}

用于链式连接函数组成的队列，回调链中的函数根据上一个函数状态情况依次被调用。

Catch

work1("abc").then { string in
  return work2(string)
}.then { number in
  return work3(number)  // Never executed.
}.then { number in
  print(number)  // Never executed.
}.catch { error in
  print("Cannot convert string to number: \(error)")
}

抛出错误，只要出现异常，忽略链中剩余的任何 then 块，catch 可以防止在链中任何位置来处理错误。

All

// Promises of same type:
all(contacts.map { MyClient.getAvatarFor(contact: $0) }).then(updateAvatars)

// Promises of different types:
all(
  MyClient.getLocationFor(contact: contact),
  MyClient.getAvatarFor(contact: contact)
).then { location, avatar in
  self.updateContact(location, avatar)
}

在一个块中等待所有函数调用结束后更新状态。例如一个页面的UI使用到三个网络请求的数据，等待全部加载完成再进行刷新。

Always

getCurrentUserContactsAvatars().then { avatars in
  self.update(avatars)
}.catch { error in
  self.showErrorAlert(error)
}.always {
  self.label.text = "All done."
}

不论 promise 结果如何，在这之后总是执行某项任务。

Recover

getCurrentUserContactsAvatars().recover { error in
  print("Fallback to default avatars due to error: \(error)")
  return self.getDefaultsAvatars()
}.then { avatars in
  self.update(avatars)
}

可以默认实现错误处理，并且不打断接下来链块操作。

Resolve

func newAsyncMethodReturningAPromise() -> Promise<Data> {
  return resolve { handler in
    MyClient.wrappedAsyncMethodWithTypical(completion: handler)
  }
}

用于返回一个Promise，提供一种常见的、方便的方法。

Timeout

超时处理

Validate

getAuthToken().validate { !$0.isEmpty }.then(getData).catch { error in
  print("Failed to get auth token: \(error))
}

validate 在不破坏链的情况下检查返回结果，来判断获取的内容是否可靠再进行接下来的操作。

When

when(
  MyClient.getLocationFor(contact: contact),
  MyClient.getAvatarFor(contact: contact)
).then { location, avatar in
  if let location = location.value, let avatar = avatar.value {
    self.updateContact(location, avatar)
  } else {  // Optionally handle errors if needed.
    if let locationError = location.error {
      self.showErrorAlert(locationError)
    }
    if let avatarError = avatar.error {
      self.showErrorAlert(avatarError)
    }
  }
}

when 与 all 类似，不同的是如果需要处理错误细节，使用when会显得更加方便。

参考：
Under the hood of Futures & Promises in Swift
google/promises/index.md