swift中，如何解决回调地狱？

问题描述

问 题

问题已经很直接，相信很多小伙伴都碰到过回调地狱，如何解决呢？

不希望听到函数式编程 rxswift reactive cocoa 这种范范而谈的以后的框架，或名词。

我希望听到的是一中推导。

比如，
我们首先定义一个monad type

enum Result<Value>{
    case Success<Value>
    case Failure<ErrorType>
}

然后在怎么怎么滴，一步步的推导，将嵌套回调转变为链式调用的。

解决方案

Hmmmm，为什么我们会想到用Async来简化回调地狱呢？我们得回头想想所谓的回调地狱到底是怎么一回事，首先一起来看一段相对简单的回调地狱吧（为了简单起见，我们先不考虑错误处理）：

getFirstItem() { firstItem in
    getSecondItem(firstItem) { secondItem in
        getThirdItem(secondItem){ thirdItem in
            //Here we get our third item
        }
    }
}

所以它到底是在干什么？如果我们将它按照人类的语言描述一遍，并尽量不遗漏掉任何的代码执行过程：

1. 异步地发出一个请求，在回调中获得请求的数据。（即firstItem）
   然后根据上一步的数据，在getSecondItem中计算出一个新的请求。

2. 异步地发出这个新的请求，并在回调中获得请求的数据。（即secondItem）
   然后根据上一步的数据，在getThirdItem中计算出一个新的请求。

3. 异步地发出这个新的请求，并在回调中获得请求的数据。（即thirdItem）

于是我们可以看到，所谓的回调地狱其实也不过是在重复地做一些计算的过程，如果我们能够找到一种对类似的计算过程的封装方法，那么我们就能解决回调地狱的问题。
这里如果直接去想，去找，真的是挺难的，原因在于我们平时写代码其实更多地是在对数据进行抽象：比如我们会去抽象一个用户，一个商品——这些东西都是一个一个的对象（或者说封装之后的数据），即便涉及到对象的方法，那本质上也是在对数据的行为进行的抽象。而现在，我们却是需要对一种计算的过程进行抽象，它需要的编程思维和我们平时所习惯的代码写法完全是不一样的！
那么，有没有类似的已经做出来的其他过程抽象的例子可以给我们参考，帮助我们进行思考呢？答案当然是有的，并且不止一个！
如果对Swift的标准库比较熟悉，那么很容易想到Optional.flatMap这个函数，这个函数的具体用法如下：

someOptionalNumber
    .flatMap(divide3) //{x in x == 0 ? nil : return 3/x}
    .flatMap(divide5) //{x in x == 0 ? nil : return 5/x}
    //我们还可以无限地链下去......

如果我们把上面这段代码像之前那样描述一遍：

1. 对一个Optional数据，确保这个数据的值不为nil，否则后面的步凑不执行。
   然后根据上一步的数据，在divide3中计算出一个新的Optional数据。

2. 对这个新的Optional数据，确保这个数据的值不为nil，否则后面的步凑不执行
   然后根据上一步的数据，在divide5中计算出一个新的Optional数据。

3. 对这个新的Optional数据……

我们发现，这个过程竟然与我们此前的描述很多部分惊人的相似！

然后根据上一步的数据，在XXX中计算出一个新的XXXX。

这句话似乎应该是一个pattern，如果它是一个pattern，肯定不止会在一个地方出现！
于是我们再来看看这个我们可能更加熟悉的函数！

[1,2,3,4,5]
    .flatMap(duplicate) // { x in return [x, x] }
    .flatMap(anotherFunction) // {x in return [x, x]}
//[1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5]

老办法，把它真正做的事情翻译一遍，并尽量不遗漏任何计算过程：

1. 遍历一个Array，得到其中的每一个数据
   然后根据上一步的数据，在duplicate中计算出一个新的Array

2. 遍历这个新的Array，得到其中的每一个数据
   然后根据上一步的数据，在anotherFunction中计算出一个新的Array

3. ......

果然出现了！
如果我们现在再根据上下文回去看我们回调地狱的问题，我们可以确信，只要我们将

然后根据上一步的数据，在XXX中计算出一个新的XXXX。

这个步骤封装好了，我们的问题也就解决了！并且我们所需要做的事情仅仅是定义一个针对回调函数的flatMap而已。
首先，让我们把一个异步函数封装进一个结构体，什么是异步函数呢？
比如：

func async(callback: String->Void){

}

这就是一个异步函数，它的签名是 (String->Void)->Void 的形式。
那么我们首先将形如 (T->Void)->Void 的函数封装起来：

struct Async<T>{
    let asyncFunction:(T->Void)->Void
}

接下来，我们观察Optional和Array的flatMap函数，他们的函数签名几乎一模一样：

flatMap<U>(transform:T->M<U>)->M<U>
其中M<U>表示Array<U>或者Optional<U>

那么，我们的flatMap也应该是这个样子！

struct Async<T>{
    let asyncFunction:(T->Void)->Void
    func flatMap<U>(transform: T->Async<U>)->Async<U>{
        //fill this function
    }

}

剩下的事情，就只是将这个函数体按照前面整理出的然后根据上一步的数据,在transform中计算出新的Async进行补玩就OK了。
好了，具体补完的代码我就不在这里写出来了，如果实在还写不出，可以去我的GitHub上面找一个Demo，但我更建议你尝试着自己将它补完。

最后，谁提Monad我跟谁急！

这篇关于swift中，如何解决回调地狱？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！