Promsie的概念是我在学习前端时接触到的概念，简而言之就是避免地狱回调，在异步编程时例如网络请求时，以往对于异步任务完成时的结果往往采取回调的方式，在OC中采取block的形式，swift和JavaScript则可以采用闭包的形式，但是一旦我们的业务比较复杂，就会出现地狱回调，如下情况所示：

Promise的初步了解

我们来考虑下面的场景(有夸张的成分)：

• 我们需要通过一个url1从服务器加载一个数据data1，data1中包含了下一个请求的url2。
• 我们需要通过data1取出url2，从服务器加载数据data2，data2中包含了下一个请求的url3。
• 我们需要通过data2取出url3，从服务器加载数据data3，data3中包含了下一个请求的url4。
• 发送网络请求url4，获取最终的数据data4。

在前端中我们会写出如下代码：

$.ajax('url1',function (data1){
   $.ajax(data1['url2'],function (data2){
       $.ajax(data2['url3'],function (data3){
            $.ajax(data3['url4'],function (data4){
               console.log(data4);
           })
       })
   })
})

接下来我们看使用Promise后的效果，ES6开始提供Promise特性的支持：

  new Promise((resolve, reject) => {
    $.ajax('url1',function (data1) {
      resolve(data1)
    })
  }).then(data1 => {
    return new Promise((resolve, reject) => {
      $.ajax('data1[url2]',function (data2) {
        resolve(data2)
      })
    })
  }).then(data2 => {
    return new Promise((resolve, reject) => {
      $.ajax('data2[url3]',function (data3) {
        resolve(data3)
      })
    })
  }).then(data3 => {
    return new Promise((resolve, reject) => {
      $.ajax('data3[url4]',function (data4) {
        console.log(data4)
      })
    })
  })

经过Promise操作后，复杂嵌套异步操作的回调结构变得清晰了许多，通过resolve这个闭包将请求的结果返回到外层，通过链式then方法的调用拿到上层resolve返回的结果，再次通过返回一个Promise对象并对拿到的结果进行一些需要的异步操作，这样的结构使得异步任务清晰了然。

Swift 中Promise的实现

在Swift中已有成熟的PromiseKit三方库支持Promise，本文主要是分析此文Swift 中实现 Promise 模式手写的一个简易的Promise模式的实现，主要是利用Swift的闭包以及链式调用的思想来实现，由于原文已有实现原理，那么废话不多说直接上代码进行分析，代码里标有注释，同时本文代码对原文代码进行了一定的修改，因为原文的代码有点小问题：

import UIKit
class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        delay(secs: 5)
            .then { (string) -> Promise<Data?> in
                // 拿到结果进行处理，并进行向下传递
                self.fetch(URL: URL(string: string)!)
            }
            .then { (data) -> Promise<String> in
                // 拿到结果进行处理，并进行向下传递
                self.decodeToString(data: data)
            }
            .startTask(success: { result in
                print(result + "-------------")
            }, failed: { Error in
                print(Error)
            })
    }

    func delay(secs: TimeInterval = 3) -> Promise<String> {
        // 这里是swift的尾随闭包写法，直接调用了init初始化方法返回了一个promise对象
        // 这个promise对象的self.task为传入的闭包
        return Promise<String> { (resolve, _) in
            DispatchQueue.main.asyncAfter(deadline: .now() + secs) {
                // 异步操作成功调用resolve回调，失败调用reject，这里只模拟成功的情况
                resolve("https://www.zhihu.com1")
            };
            
        }
    }

    func fetch(URL: URL) -> Promise<Data?> {
        return Promise<Data?> { (resolve, reject) in
            let request = URLRequest(url: URL)
            let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
                if (error != nil) {
                    reject(error!)
                } else {
                    /* 这里的resolve其实就是{ self.resolve(result: $0) } 这个闭包里的resolove是函数，会调用闭包 self.resolveCallback?(result) 而resolveCallback就是调用startTask传入的闭包{ resolve($0) }
                     而最后的这个resolve就是后面调用then确定的也就是：这里的result为网址返回值
                    (result) in
                    let wrapped = f(result)
                    wrapped.success { resolve($0) }
                    */
                    resolve(data)
                }
            }
            task.resume()
        }
    }

    func decodeToString(data: Data?) -> Promise<String> {
        return Promise<String> { (resolve, _) in
            if (data == nil) {
                resolve("")
            } else {
                /*
                 这里的resolve其实就是{ self.resolve(result: $0) } 这个闭包里的resolove是函数，会调用闭包 self.resolveCallback?(result) 而resolveCallback就是调用success传入的闭包{ resolve($0) }
                  而最后的这个startTask确定的：这里的resolve传入的值是String函数处理过的
                 (result) in
                     print(result + "--------------")
                 所以进行了最后的打印
                 */      
                resolve(String(data: data!, encoding: String.Encoding.utf8) ?? "")
            }
        }
    }

}

class Promise<T> {
    typealias ResolveCallback = (T) -> Void
    typealias RejectCallback = (Error) -> Void
    typealias AsyncTask = (@escaping ResolveCallback,@escaping RejectCallback) -> Void
    
    let task: AsyncTask
    
    var resolveCallback: ResolveCallback?
    var rejectCallback: RejectCallback?
    
    init(_ task: @escaping AsyncTask) {
        self.task = task
    }
    
    private func resolve(result: T) {
        self.resolveCallback?(result)
    }
    
    private func reject(error: Error) {
        self.rejectCallback?(error)
    }
    
    func startTask(success: @escaping ResolveCallback,failed:@escaping RejectCallback) {
        self.resolveCallback = success
        self.rejectCallback = failed
        self.task({ self.resolve(result: $0) }, { self.reject(error: $0) })
    }
    
    func then<U>(f:@escaping (T) -> Promise<U>) -> Promise<U> {
        return Promise<U> { (resolve, reject) in
            self.task(
                { (result) in
                    // result = ”“ 和String函数处理过的值
                    let wrapped = f(result)
                    // wrapped是promise对象，通过调用startTask来执行内部异步任务，然后回调了then内部Promise的reslove，而这个resolve和failed又会由下一个then来确定
                    wrapped.startTask(success: {resolve($0)}, failed: {reject($0)})
                },
                { (error) in
                    reject(error)
            })
        }
    }
}

代码分析

promise类结构分析

• 首先是创建了一个promise的类，此类初始化需要传入一个代表异步任务的闭包，异步任务的闭包有二个参数，二个参数也为二个闭包，且参数都采用了泛型。
• startTask方法用来启动异步任务，也称之为冷启动，只有调用了startTask才会启动Promise的异步任务。
• then方法是用来链式调用的，当promise对象调用then方法时会依然返回一个promise对象，这样可以继续调用then方法继而链式调用下去。

代码执行流程分析

• 在调用delay(secs: 5)方法时，返回的是一个promise对象，这个promise传入了一个闭包代表异步任务，并用self.task进行了保存，这里异步任务采用延时的方式进了模拟，实际开发中可能为网络请求，同时此闭包有二个参数，分别为resolve和reject，分别代表异步任务成功时和失败时的回调，也就是上面promise类结构分析中的第一点，且由于没有失败的情况，这里直接调用了resolve成功时的回调。
• delay(secs: 5)返回的promise对象的异步任务需要传入的resolve和reject只有在调用的时候才能确定，何时开始调用呢？其实对于promise对象来说，启动异步任务的方法只有一个就是调用startTask， 在链式调用then方法时返回的依然是一个promise对象，而这个promise对象不同点在于其异步任务是执行了调用then前的promise对象的self.task并传递了成功时回调和失败时回调二个闭包，而传递的这个成功时的闭包则很有讲究，当then之前的promise对象执行resolve时，会拿到这个promise对象异步执行的结果，然后将这个参数顺势传入执行了调用then方法时传入的闭包f并执行，此时依然返回一个promise对象，我们想要的是执行这个promise对象内部的异步任务，并且把异步任务的结果抛出来，怎么办？肯定还是得调动startTask呀，为了将结果从调用then产生的promise对象抛出去，这里的startTask传入的二个回调闭包则要主动调用调用then时初始化promsie时定义的resolve和reject。
• then的链式调用就好像用炸药开山时，用引线将炸药包首尾相连，直到最后一个炸药包埋进山体的深度达到了炸开山体的深度，则点燃第一个炸药的引线，炸药环环爆炸炸开山体。promise对像通过then相连，当挂载startTask时则会执行第一个promise对象的异步任务，并将异步任务结果向下传递到下一个promise对象。
  
  

总结

Promise能让多层嵌套的异步任务结构变得更加清晰，本文是实现了Swift的promise方式，和ES6中的promise使用起来还是稍微麻烦点，但是核心思想就是链式调用配合闭包来实现，仔细体会会发现别有洞天，当然也可以直接用三方框架简单明了。