在异步编程中，除了竟态处理、资源利用以外，另外一个难点就是流程管理。在拥有匿名函数、闭包这些特性的编程语言中，我们通常可以使用回调函数来做一个异步任务完成或失败时的处理。但当我们的业务逻辑逐渐复杂时，就会产生回调嵌套，整个事件流将十分混乱。相信大家对 Node.js 的回调陷阱一定有所耳闻了。于是各种各样事件流处理的库就产生了，比如 NPM.js 社区中著名的 q、bluebird 都是用来解决回调陷阱的，它们所采用的模式就是我们所说的 Promise，也是我们今天要谈的模式。当然异步流程处理的方式远不止 Promise 这一种，在支持生成器语义的语言里我们还能用 yield + generator 来实现协程，co就是这种思想。但是 Swift 并不支持，所以我们就不讨论了。

Getting Started

相信大家在日常开发中对下面这种模式已经不陌生了：

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。