前言
在上篇中，我談到了可以用promise來解決Callback hell的問題，這篇我們換一種方式一樣可以解決這個問題。
我們先分析一下為何promise能解決多層回調嵌套的問題，經過上篇的分析，我總結也一下幾點：
1.promise封裝了所有異步操作，把異步操作封裝成了一個“盒子”。
2.promise提供了Monad，then相當于flatMap。
3.promise的函數返回對象本身，于是就可形成鏈式調用
好了，既然這些能優雅的解決callback hell，那么我們只要能做到這些，也一樣可以完成任務。到這里大家可能就已經恍然大悟了，Swift就是完成這個任務的最佳語言！Swift支持函數式編程，分分鐘就可以完成promise的基本功能。
一.利用Swift特性處理回調Callback hell
我們還是以上篇的例子來舉例，先來描述一下場景：
假設有這樣一個提交按鈕，當你點擊之后，就會提交一次任務。當你點下按鈕的那一刻，首先要先判斷是否有權限提交，沒有權限就彈出錯誤。有權限提交之后，還要請求一次，判斷當前任務是否已經存在，如果存在，彈出錯誤。如果不存在，這個時候就可以安心提交任務了。
那么代碼如下：
func requestAsyncOperation(request : String , success : String -> Void , failure : NSError -> Void)
{
WebRequestAPI.fetchDataAPI(request, success : { result in
WebOtherRequestAPI.fetchOtherDataAPI ( result , success : {OtherResult in
[self fulfillData:OtherResult];
let finallyTheParams = self.transformResult(OtherResult)
TaskAPI.fetchOtherDataAPI ( finallyTheParams , success : { TaskResult in
let finallyTaskResult = self.transformTaskResult(TaskResult)
success(finallyTaskResult)
},
failure:{ TaskError in
failure(TaskError)
}
)
},failure : { ExistError in
failure(ExistError)
}
)
} , failure : { AuthorityError in
failure(AuthorityError)
}
)
}
接下來我們就來優雅的解決上述看上去不好維護的Callback hell。
1.首先我們要封裝異步操作，把異步操作封裝到Async中，順帶把返回值也一起封裝成Result。
enum Result <T> {
case Success(T)
case Failure(ErrorType)
}
struct Async<T> {
let trunk:(Result<T>->Void)->Void
init(function:(Result<T>->Void)->Void) {
trunk = function
}
func execute(callBack:Result<T>->Void) {
trunk(callBack)
}
}
2.封裝Monad，提供Map和flatMap操作。順帶返回值也返回Async，以方便后面可以繼續鏈式調用。
// Monad
extension Async{
func map<U>(f: T throws-> U) -> Async<U> {
return flatMap{ .unit(try f($0)) }
}
func flatMap<U>(f:T throws-> Async<U>) -> Async<U> {
return Async<U>{ cont in
self.execute{
switch $0.map(f){
case .Success(let async):
async.execute(cont)
case .Failure(let error):
cont(.Failure(error))
}
}
}
}
}
這是我們把異步的過程就封裝成一個盒子了，盒子里面有Map，flatMap操作，flatMap對應的其實就是promise的then
3.我們可以把flatMap名字直接換成then，那么之前那30多行的代碼就會簡化成下面這樣：
func requestAsyncOperation(request : String ) -> Async <String>
{
return fetchDataAPI(request)
.then(fetchOtherDataAPI)
.map(transformResult)
.then(fetchOtherDataAPI)
.map(transformTaskResult)
}
基本上和用promise一樣的效果。這樣就不用PromiseKit庫，利用promise思想的精髓，優雅的完美的處理了回調地獄。這也得益于Swift語言的優點。
文章至此，雖然已經解決了問題了，不過還沒有結束，我們還可以繼續再進一步討論一些東西。
二.進一步的討論
1.@noescape，throws，rethrows關鍵字
flatMap還有這種寫法：
func flatMap<U> (@noescape f: T throws -> Async<U>)rethrows -> Async<U>
@noescape 從字面上看，就知道是“不會逃走”的意思，這個關鍵字專門用于修飾函數閉包這種參數類型的，當出現這個參數時，它表示該閉包不會跳出這個函數調用的生命期：即函數調用完之后，這個閉包的生命期也結束了。
在蘋果官方文檔上是這樣寫的：
A new @noescape attribute may be used on closure parameters to functions. This indicates that the parameter is only ever called (or passed as an @noescape parameter in a call), which means that it cannot outlive the lifetime of the call. This enables some minor performance optimizations, but more importantly disables the self. requirement in closure arguments.
那什么時候一個閉包參數會跳出函數的生命期呢？
引用唐巧大神的解釋：
在函數實現內，將一個閉包用 dispatch_async
嵌套，這樣這個閉包就會在另外一個線程中存在，從而跳出了當前函數的生命期。這樣做主要是可以幫助編譯器做性能的優化。
throws關鍵字是代表該閉包可能會拋出異常。
rethrows關鍵字是代表這個閉包如果拋出異常，僅可能是因為傳遞給它的閉包的調用導致了異常。
2.繼續說說上面例子里面的Result，和Async一樣，我們也可以繼續封裝Result，也加上map和flatMap方法。
func ==<T:Equatable>(lhs:Result<T>, rhs:Result<T>) -> Bool{
if case (.Success(let l), .Success(let r)) = (lhs, rhs){
return l == r
}
return false
}
extension Result{
func map<U>(f:T throws-> U) -> Result<U> {
return flatMap{.unit(try f($0))}
}
func flatMap<U>(f:T throws-> Result<U>) -> Result<U> {
switch self{
case .Success(let value):
do{
return try f(value)
}catch let e{
return .Failure(e)
}
case .Failure(let e):
return .Failure(e)
}
}
}
3.上面我們已經把Async和Result封裝了map方法，所以他們也可以叫做函子(Functor)。接下來可以繼續封裝，把他們都封裝成適用函子(Applicative Functor)和單子(Monad)
適用函子(Applicative Functor)根據定義：
對于任意一個函子F，如果能支持以下運算，該函子就是一個適用函子：
func pure<A>(value:A) ->F<A>
func <*><A,B>(f:F<A - > B>, x:F<A>) ->F<B>
以Async為例，我們為它加上這兩個方法
extension Async{
static func unit(x:T) -> Async<T> {
return Async{ $0(.Success(x)) }
}
func map<U>(f: T throws-> U) -> Async<U> {
return flatMap{ .unit(try f($0)) }
}
func flatMap<U>(f:T throws-> Async<U>) -> Async<U> {
return Async<U>{ cont in
self.execute{
switch $0.map(f){
case .Success(let async):
async.execute(cont)
case .Failure(let error):
cont(.Failure(error))
}
}
}
}
func apply<U>(af:Async<T throws-> U>) -> Async<U> {
return af.flatMap(map)
}
}
unit和apply就是上面定義中的兩個方法。接下來我們在看看Monad的定義。
單子(Monad)根據定義：
對于任意一個類型構造體F定義了下面兩個函數，它就是一個單子Monad：
func pure<A>(value:A) ->F<A>
func flatMap<A,B>(x:F<A>)->(A->F<B>)->F<B>
還是以Async為例，此時的Async已經有了unit和flatMap滿足定義了，這個時候，就可以說Async已經是一個Monad了。
至此，我們就把Async和Result都變成了適用函子(Applicative Functor)和單子(Monad)了。
4.再說說運算符。
flatMap函數有時候會被定義為一個運算符>>=。由于它會將第一個參數的計算結果綁定到第二個參數的輸入上面，這個運算符也會被稱為“綁定(bind)”運算.
為了方便，那我們就把上面的4個操作都定義成運算符吧。
func unit<T> (x:T) -> Async<T> {
return Async{$0(.Success(x))}
}
func <^> <T, U> (f: T throws-> U, async: Async<T>) -> Async<U> {
return async.map(f)
}
func >>= <T, U> (async:Async<T>, f:T throws-> Async<U>) -> Async<U> {
return async.flatMap(f)
}
func <*> <T, U> (af: Async<T throws-> U>, async:Async<T>) -> Async<U> {
return async.apply(af)
}
按照順序，第二個對應的就是原來的map函數，第三個對應的就是原來的flatMap函數。
5.說到運算符，我們這里還可以繼續回到文章最開始的地方去討論一下那段回調地獄的代碼。上面我們通過map和flatMap成功的展開了Callback hell，其實這里還有另外一個方法可以解決問題，那就是用自定義運算符。這里我們用不到適用函子的<*>，有些問題就可能用到它。還是回到上述問題，這里我們用Monad里面的運算符來解決回調地獄。
func requestAsyncOperation(request : String ) -> Async <String>
{
return fetchDataAPI(request) >>= (fetchOtherDataAPI) <^>(transformResult) >>= (fetchOtherDataAPI) <^> (transformTaskResult)
}
通過運算符，最終原來的40多行代碼變成了最后一行了！當然，我們中間封裝了一些操作。
三.總結
經過上篇和本篇的討論，優雅的處理"回調地獄Callback hell"的方法有以下幾種:
1.使用PromiseKit
2.使用Swift的map和flatMap封裝異步操作(思想和promise差不多)
3.使用Swift自定義運算符展開回調嵌套
目前為止，我能想到的處理方法還有2種：
4.使用Reactive cocoa
5.使用RxSwift
下篇或者下下篇可能應該就是討論RAC和RxSwift如果優雅的處理回調地獄了。如果大家還有什么其他方法能優雅的解決這個問題，也歡迎大家提出來，一起討論，相互學習！
