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使用起来还是稍微麻烦点，但是核心思想就是链式调用配合闭包来实现，仔细体会会发现别有洞天，当然也可以直接用三方框架简单明了。
