首先在脑海里回想一下 map 和 flattenMap 的区别。flattenMap 会将 transform 函数的返回类型先拍扁，再组合成本身的复合类型。标准库有3个 flatMap。
Sequence.flatMap<S>(_: (Element) -> S)
-> [S.Element] where S : Sequence
Optional.flatMap<U>(_: (Wrapped) -> U?) -> U?
Sequence.flatMap<U>(_: (Element) -> U?) -> [U]
在 Swift 4.1 中引入的 compactMap 的新函数实际上是第三个版本的重命名，没什么其它特别之处。想知道 Why 的同学们，请继续看下去，我将带着大家继续探究一下这么修改的理由。在这之前，我们首先复习一下 map 和 flatMap 的各个版本。
1.最广为人知的 Sequence.flatMap
Sequence.flatMap<S>(_: (Element) -> S)
-> [S.Element] where S : Sequence
let numbers = [1, 2, 3, 4]
let mapped = numbers.map {
Array(repeating: $0, count: $0)}
// [[1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]
let flatMapped = numbers.flatMap {
Array(repeating: $0, count: $0) }
// [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
上述代码意图是：数字是几就重复几次，但 map 与 flatMap 的结果有明显区别。
map 是没拍扁的：closure 返回的是数组，map 最终将它们组成一个二维的数组；
flatMap 中执行的 closure 返回的是同样的数组，但是 flatMap 将每一个返回的数组都拍扁，取出它的元素，构成一个大的一维数组。
这个版本的 map 和 flatMap 是大家最为熟悉的。这里的s.flatMap(transform)等价于Array(s.map(transform).joined())
2.Optional也有flatMap
Optional.flatMap<U>(_: (Wrapped) -> U?) -> U?
Optional的版本知道的和日常使用的就没有那么多了。先仔细看一下这两个函数的定义，区别仅在一个处：
func map<U>( transform: (Wrapped) -> U) -> U?
func flatMap<U>( transform: (Wrapped) -> U?) -> U?
我们首先从概念上理解这两个函数的区别：
map 函数是：在 transform 函数返回的类型上，最终给你再套一个 Optional ；
flatMap 函数从概念上来讲则是在 transform 函数返回结果后，帮你退一层 Optional，再帮你套一个。而对于 Optional 这个特别的例子，由于 transform 的返回类型恰好等同于整个函数的返回类型，都是 U?，所以函数内部实现可以直接返回 transform 的运行结果，而不用做解开一个再套上一个 Optional 的多余动作了。
我们再从用途上看看 flatMap 的作用。如果 Optional 不是使用 flatMap，那么在一个 Optional上，执行一个返回任意类型 Optional 的函数，那么可能得到的类型是两层 Optional。而 flatMap帮助我们压掉了一个层，所以叫 flatMap。以下是 Optional 的 map 和 flatMap 的用法：
let possibleNumber: Int? = Int("42")
let possibleSquare = possibleNumber.map { $0 * $0 }
let possibleURL: URL? = URL(string: "https://www.liulishuo.com")
let possibleHost = possibleURL.flatMap{$0.host}
从上面的例子中可以看到，Optional 版本的 map 和 flatMap，差别还是在于 closure 中的返回值，前者乘法表达式是非 Optional 的，后者 $0.host 是 Optional 的，两个段代码分别都得到了自己所预期的一层Optional的结果。
了解了这个两个函数的用法后，我们不免联想到，是否可以换用 Optional Chaining 实现同样的功能呢？，我尝试写了看下面两段“等价的”代码：
// 编译不过
let possibleSquare2 = Int("42")?.map{ $0 * $0 }
// 可以编译
let possibleHost2 = possibleURL?.host
第一个例子，看上去很合理，似乎是在一个 Optional 上调用 map 方法？实则编译不过，因为Int("42")是个 Optional ，后面的问号是 Optional Chaining 的语法，Int 上并没有 map 方法，编译不过。这里提醒我们 Optional 的 Chaining 和 Mapping 即便可以混用也谨慎使用，表达式有一定的复杂度的话可能更会看混意义。
在第二个例子中，使用 Optional Chaining 是个更简单的写法。
那么问题来了，什么时候使用 Optional Chaining，什么时候使用 Optional 的 Mapping 呢？
我认为，他们的差异在于 receiver 在类型转换过程中承担的角色，Optional Chaining 中只能作为 receiver，而 Optional Mapping 函数还能作为参数，更为通用，因而第一个例子只能用 Mapping 实现；另一个方面，Optional Chaining 只能写成串联表达式，而 closure 当中可以写更复杂的转换逻辑，还是用例子来说明：
let possibleNumber: Int? = Int("42")
let nonOverflowingSquare = possibleNumber.flatMap {
x -> Int? in
let (result, overflowed) = x.multipliedReportingOverflow(by: x)
return overflowed ? nil : result
}
3. 另一个Sequence.flatMap被改名
Sequence.flatMap<U>(_: (Element) -> U?) -> [U]
终于聊到了今天的主角，这个函数压扁 Optional 类型，组成数组，看上去很综合。我们通过一个例子先了解一下它的设计初衷。
let possibleNumbers = ["1", "2", "three", "///4///", "5"]
let flatMapped: [Int] = possibleNumbers.flatMap {
str in Int(str) }
// [1, 2, 5]
很有用有没有，完美的拯救了一个 failable 的 mapping，如果这里使用 map，就返回 [Int?] 了而且包含 nil。因此这个函数很有用的，但我们看一下这个例子：
struct Person {
var age: Int
var name: String
}
func getAges(people: [Person]) -> [Int] {
return people.flatMap { $0.age }
}
这可以编译吗？是的，因为 Int 可以隐式转成 Int?，再参与压扁。但其实这一来二去没有一点必要，况且，为什么不用 map？是的，这里应该用 map。所以，为了避免这样的误用，在Swift 4.1 中会提示：
'flatMap' is deprecated: Please use compactMap(_:) for the case where closure returns an optional value
当closure返回Optional的时候，在Swift 4.1 中应该使用compactMap。
let flatMapped: [Int] = possibleNumbers.compactMap {
str in Int(str) }
这样一来，一些针对map和flatMap重载来设计的烧脑面试题也可以退散了。
4. 小结
- 回顾了 flatMap 和 map 的区别在于前者压扁后者没有。
- 比较了 Optional Mapping 和 Chaining 简单用法上的区别。
- 解释了为什么另一个版本的
Sequence.flatMap需要改名成compactMap。
Swift 4.1 新特性系列文章
Swift 4.1 新特性 (1) Conditional Conformance
Swift 4.1 新特性 (2) Sequence.compactMap
Swift 4.1 新特性 (3) 合成 Equatable 和 Hashable
Swift 4.1 新特性 (4) Codable的改进
