谈谈 Swift 中的 map 和 flatMap

(Self.Generator.Element) -> T

result = numbers.flatMap { $2 }

 
我们对同样的数组使用?flatMap?进行处理， 得到了同样的结果。 那 flatMap 和 map 到底有什么区别呢？?
 

 
咱们再来看另一个例子：
 

 

 

let numbersCompound = [[3],[4,152);">5,152);">6]];
var res = numbersCompound.0.map{ $2 } }
// [[3,5],[6,7,8]]

var flatRes = numbersCompound.flatMap { $
 
这里就看出差别了。 对于二维数组， map 和 flatMap 的结果就不同了。 我们先来看第一个调用：
 

 

 

 
numbersCompound.map { ... }?这个调用实际上是遍历了这里两个数组元素?[1,2,3]?和?[4,6]。 因为这两个元素依然是数组，所以我们可以对他们再次调用 map 函数：$0.map{ $0 + 2 }。 这个内部的调用最终将数组中所有的元素加 2。
 

 
再来看看 flatMap 的调用：
 

 

 

 
flatMap 依然会遍历数组的元素，并对这些元素执行闭包中定义的操作。 但唯一不同的是，它对最终的结果进行了所谓的 “降维” 操作。 本来原始数组是一个二维的， 但经过 flatMap 之后，它变成一维的了。
 

 
flatMap 是如何做到的呢，它的原理是什么，为什么会存在这样一个函数呢？ 相信此时你脑海中肯定会浮现出类似的问题。
 

 
下面咱们再来看一下 flatMap 的定义,还是抛去?@noescape,?rethrows?这些无关逻辑的关键字：
 

 

 
flatMap<T>(transform: (Self.Generator.Element) throws -> T?) -> [T]
flatMap<S : SequenceType>(transform: (Self.Generator.Element) -> S) -> [S.Generator.Element]
 
   

 

 
和 map 不同， flatMap 有两个重载。 参照我们刚才的示例， 我们调用的其实是第二个重载：
 

 

 
Self.Generator.Element) -> S) -> [S.Generator.Element]
 
   

 

 
flatMap 的闭包接受的是数组的元素，但返回的是一个 SequenceType 类型，也就是另外一个数组。 这从我们刚才这个调用中不难看出：
 

 

 
numbersCompound.flatMap { $2 } }
 
   

 

 
我们传入给 flatMap 一个闭包?$0.map{ $0 + 2 }?,这个闭包中，又对 $0 调用了 map 方法， 从 map 方法的定义中我们能够知道，它返回的还是一个集合类型，也就是 SequenceType。 所以我们这个 flatMap 的调用对应的就是第二个重载形式。
 

 
那么为什么 flatMap 调用后会对数组降维呢？ 我们可以从它的源码中窥探一二（Swift 不是开源了吗~）。
 

 
文件位置： swift/stdlib/public/core/SequenceAlgorithms.swift.gyb
 

 

 

extension Sequence {
 ? ?
 ? ?//...
 ? ?
public flatMap<S : Sequence>(
 ? ?@noescape transform: (${GElement}) throws -> S
 ?) rethrows -> [S.${GElement}] {
 ? ?var result: [S.${GElement}] = []
 ? ?for element in self {
 ? ? ?result.append(contentsOf: try transform(element))
 ? ?}
 ? ?return result
 ?}
 ?
 ?//...
 ?
}
 
   

 

 
这就是 flatMap 的完整源码了， 它的源码也很简单， 对遍历的每一个元素调用?try transform(element)。 transform 函数就是我们传递进来的闭包。?
 

 
然后将闭包的返回值通过 result.append(contentsOf:) 函数添加到 result 数组中。
 

 
那我们再来看一下 result.append(contentsOf:) 都做了什么， 它的文档定义是这样：
 
 
 
Append the elements of newElements to self.
 
 
简单说就是将一个集合中的所有元素，添加到另一个集合。 还以我们刚才这个二维数组为例：
 

 

 

 
flatMap 首先会遍历这个数组的两个元素?[1,6]， 因为这两个元素依然是数组， 所以我们可以对他们再进行 map 操作：?$0.map{ $0 + 2 }。
 

 
这样， 内部的?$0.map{ $0 + 2 }?调用返回值类型还是数组， 它会返回?[3,5]?和?[6,8]。?
 

 
然后， flatMap 接收到内部闭包的这两个返回结果， 进而调用 result.append(contentsOf:) 将它们的数组中的内容添加到结果集中，而不是数组本身。
 

 
那么我们最终的调用结果理所当然就应该是?[3,8]?了。
 

 
仔细想想是不是这样呢~
 

 
flatMap 的另一个重载
 

 
我们刚才分析了半天， 其实只分析到 flatMap 的一种重载情况， 那么另外一种重载又是怎么回事呢：?
 

 

 
Self.Generator.Element) -> T?) -> [T]

[Optional("AA"),Optional("BB"),152);">"CC")]

``` 

而使用 `print` 函数输出 flatMap 的结果集时，会得到这样的输出：

``` swift

["CC"]

Sequence {
 ?
 ?// ... 
 ?public flatMap<T>(
 ? ?@noescape transform: (${GElement}) throws -> T?
 ?) rethrows -> [T] {
 ? ?var result: [T] = []
 ? ?self {
 ? ? ?if let newElement = try transform(element) {
 ? ? ? ?result.append(newElement)
 ? ? ?}
 ? ?}
 ? ?// ... 
 ?
}