在异步编程中，除了竟态处理、资源利用以外，另外一个难点就是流程管理。在拥有匿名函数、闭包这些特性的编程语言中，我们通常可以使用回调函数来做一个异步任务完成或失败时的处理。但当我们的业务逻辑逐渐复杂时，就会产生回调嵌套，整个事件流将十分混乱。相信大家对 Node.js 的回调陷阱一定有所耳闻了。于是各种各样事件流处理的库就产生了，比如 NPM.js 社区中著名的 q、bluebird 都是用来解决回调陷阱的，它们所采用的模式就是我们所说的 Promise，也是我们今天要谈的模式。当然异步流程处理的方式远不止 Promise 这一种，在支持生成器语义的语言里我们还能用 yield + generator 来实现协程，co就是这种思想。但是 Swift 并不支持，所以我们就不讨论了。
相信大家在日常开发中对下面这种模式已经不陌生了：
dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)) {
// Do something in background.
dispatch_async(dispatch_get_main_queue()) {
// Update the UI.
}
}
类似用法的还有诸如权限认证、NSURLSession，都有这样的回调，如果逻辑稍微复杂一些就会出现回调陷阱。下面我们应用 Promise 来将它们平坦化，通过连接就可以实现链式的事件响应。
我们先看看用了 Promise 后是一番怎样的景象：
doSomething()
.then( doAnotherThing )
.then( doSomethingElse )
.success( someHandler )
是不是瞬间清晰了很多？我们来分析一下如何实现。
首先，doSomething() 会返回一个 Promise 对象，Promise 对象在构造函数中接受一个函数作为参数，这个函数就是用来启动异步任务的。而这个函数又有两个参数，分别是成功时的回调和失败时的回调。
我们下面就来实现这个 Promise 类：
class Promise<T> {
typealias ResolveCallback = (T) -> Void
typealias RejectCallback = (ErrorType) -> Void
typealias AsyncTask = (ResolveCallback, RejectCallback) -> Void
let task: AsyncTask
var resolveCallback: ResolveCallback?
var rejectCallback: RejectCallback?
init(_ task: AsyncTask) {
self.task = task
}
}
通过泛型表示异步任务最终得到的结果的类型，对于失败的情况，传递一个实现 ErrorType 协议的对象作为错误的原因。
下面我们看如何响应结果并启动任务：
...
func success(callback: ResolveCallback) {
self.resolveCallback = callback
self.task({ self.resolve($0) }, { self.reject($0) })
}
func failed(callback: RejectCallback) {
self.rejectCallback = callback
}
...
我这里采用了冷启动的方式，也就是说仅当有响应函数被挂载时才启动异步任务，如果你想在 Promise 一被创建时就启动异步任务（也就是热启动），就需要用一个属性来存放任务的结果，以免响应函数还没被挂载，这个异步任务就完成了，这样这个结果就丢失了。
异步任务启动的方式是将 resolve 、 reject 作为参数传给异步任务启动函数，当异步任务自身的回调调用时，这个 Promise 对象就能做出响应处理，将这个事件传递给它的响应函数。
当然，resolve 、 reject函数也很简单，就是执行回调：
private func resolve(result: T) {
self.resolveCallback?(result)
}
private func reject(error: ErrorType) {
self.rejectCallback?(error)
}
链式调用
到现在我们并没有实现 Promise 的精髓，还不能链式调用。所谓的链式调用就是当一个 Promise 完成时，立即用一个变换函数将结果传给下一个 Promise 去执行，以此类推，这样我们构造一串操作之后再一并启动，实现上面我说到的冷启动。
那么这个核心函数就是 then，这个函数接受一个变换函数作为参数，这个变换函数接受 Promise 结果然后构造出一个新的 Promise 对象，然后返回。由于 then 返回的也是 Promise 因此我们可以用链式语法不断连接多个操作，十分方便。
那么连接后的启动顺序回事怎样的呢？举个例子：
promise1.then(genPromise2).then(genPromise3).success(...)
那么最终得到的 Promise 对象就是这样的：
promise3( promise2( promise1 ) )
最后一个 then 连接的 Promise 对象包裹了上一个对象，以此类推，那么在启动时，当然也是最后一个对象被启动，只不过由于这个 Promise 对象是被封装过的，所以它会先触发上一个对象，待拿到结果后再传递给自己执行，仍然以此类推，就能保证执行顺序是正确的。
说的很抽象，直接看代码吧：
func then<U>(f: (T) -> Promise<U>) -> Promise<U> {
return Promise<U> { (resolve, reject) in
self.task(
{ (result) in
let wrapped = f(result)
wrapped.success { resolve($0) }
},
{ (error) in
reject(error)
})
}
}
可以看到我们在两个 Promise 对象之间又封装了一个 Promise 对象，作为协调者，它会先执行之前的异步任务，然后再传给下一个任务，那么这个函数就会返回封装后的 Promise 对象。
下面是完整的代码：
class Promise<T> {
typealias ResolveCallback = (T) -> Void
typealias RejectCallback = (ErrorType) -> Void
typealias AsyncTask = (ResolveCallback, RejectCallback) -> Void
let task: AsyncTask
var resolveCallback: ResolveCallback?
var rejectCallback: RejectCallback?
init(_ task: AsyncTask) {
self.task = task
}
private func resolve(result: T) {
self.resolveCallback?(result)
}
private func reject(error: ErrorType) {
self.rejectCallback?(error)
}
func success(callback: ResolveCallback) {
self.resolveCallback = callback
self.task({ self.resolve($0) }, { self.reject($0) })
}
func failed(callback: RejectCallback) {
self.rejectCallback = callback
}
func then<U>(f: (T) -> Promise<U>) -> Promise<U> {
return Promise<U> { (resolve, reject) in
self.task(
{ (result) in
let wrapped = f(result)
wrapped.success { resolve($0) }
},
{ (error) in
reject(error)
})
}
}
}
下面我们试试怎么使用这个 Promise 对象，我首先定义三个操作：
func delay(secs: UInt64) -> Promise<Void> {
return Promise<Void> { (resolve, _) in
let time = dispatch_time(DISPATCH_TIME_NOW, Int64(NSEC_PER_SEC * secs))
dispatch_after(time, dispatch_get_main_queue()) {
resolve()
}
}
}
func fetch(URL URL: NSURL) -> Promise<NSData?> {
return Promise<NSData?> { (resolve, reject) in
let task = NSURLSession.sharedSession().dataTaskWithURL(URL) { (data, response, error) in
if (error != nil) {
reject(error!)
} else {
resolve(data)
}
}
task.resume()
}
}
func decodeToString(data: NSData?) -> Promise<String> {
return Promise<String> { (resolve, _) in
if (data == nil) {
resolve("")
} else {
resolve(String(data: data!, encoding: NSUTF8StringEncoding) ?? "")
}
}
}
这些操作里有异步操作，也有同步操作，但都能适应 Promise 模式，每个函数都返回一个 Promise 对象。
然后我们构造一个链式操作：
delay(5)
.then { () -> Promise<NSData?> in
fetch(URL: NSURL(string: "https://www.zhihu.com")!)
}
.then { (data) -> Promise<String> in
decodeToString(data)
}
.success { (result) in
print(result)
}
XCPlaygroundPage.currentPage.needsIndefiniteExecution = true
注意：我这个例子是在 Playground 里做的，所以为了让异步任务能够执行，我们需要设置一个属性，以免 Playground 在主线程完毕后结束程序。
结果符合我们的预期，在 5 秒的延时之后，网络请求被执行，然后转码，最终打印出来。
总结事实上，Promise 模式被利用得最好的应该是 JavaScript，我们只不过在其他语言中借鉴这种做法，然后给出响应的实现罢了。当然本文只是简单剖析 Promise 的内部原理，很多细节可能没有太完善，如果你喜欢这种编程方式，可以尝试一下成熟的 PromiseKit，它有 Objective-C 和 Swift 的实现。
当然你也可以尝试一下具有类似思想的反应式函数式编程框架，比如 ReactiveX。
作者：Cyandev
------------------越是喧嚣的世界，越需要宁静的思考------------------ 合抱之木，生于毫末；九层之台，起于垒土；千里之行，始于足下。 积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里；不积小流，无以成江海。骐骥一跃，不能十步；驽马十驾，功在不舍。锲而舍之，朽木不折；锲而不舍，金石可镂。蚓无爪牙之利，筋骨之强，上食埃土，下饮黄泉，用心一也。蟹六跪而二螯，非蛇鳝之穴无可寄托者，用心躁也。
