前言：swift是一门很优雅，很简洁，功能很强大的语言，同时也是一门很复杂的语言。进门比较简单，看完苹果官方的文档就可以基本入门，进阶很难，很多比较好用的特性需要深入探索。
1.高阶函数
在Wikipedia中定义，高级函数至少满足下面一个条件：
- 接收一个或者多个函数作为传入参数
- 把函数作为返回结果
举个例子：
func higherOrderFunction(str: String, argument: ((String) -> String)) -> String {
return argument(str)
}
let result = higherOrderFunction(str: "hello world!", argument: {$0})
//hello world!
//接收一个传入值和返回值都为字符串的函数为参数，返回一个字符串位结果
2.基本使用
- ** Map**
map接收一个闭包作为参数，然后遍历整个数组，执行闭包里面的操作，可以看作对数组里所有的元素做了一个映射，返回来的是一个数组。
举个例子：
let numbers = [1, 2, 3, 4, 5, 6, 7, 8]
let result = numbers.map{$0+2} //[3, 4, 5, 6, 7, 8, 9, 10]
先来看一下map的定义：
func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
去掉无关的修饰词：
func map<T>(_ transform: (Element) -> T) -> [T]
可以看出来map接收了一个闭包transform为参数，闭包参数是Element代表数组里的一个元素，返回值是一个范型，和传入参数类型无关，并且闭包的返回值和map函数的返回值是同一类型，都是范型T，也就是说map可以返回和数组元素不一样类型的值。
举个例子：
let numbers = [1, 2, 3, 4, 5, 6, 7, 8]
let result = numbers.map{"No.\($0)"} //["No.1", "No.2", "No.3", "No.4", "No.5", "No.6", "No.7", "No.8"]
再进一步，我们去看一下map的源码实现：
@_inlineable
public func map<T>(
_ transform: (Iterator.Element) throws -> T
) rethrows -> [T] {
// TODO: swift-3-indexing-model - review the following
let count: Int = numericCast(self.count)
if count == 0 {
return []
}
var result = ContiguousArray<T>()
result.reserveCapacity(count)
var i = self.startIndex
for _ in 0..<count {
result.append(try transform(self[i]))
formIndex(after: &i)
}
_expectEnd(of: self, is: i)
return Array(result)
}
最重要的代码
var result = ContiguousArray<T>()
for _ in 0..<count {
result.append(try transform(self[i]))
formIndex(after: &i)
}
新生成一个数组，数组里面填充闭包操作后的返回值，最后返回该数组。所以，map高阶函数适合一些需要对整个数组元素做一些额外操作的需求。
- flatMap
flatMap函数和map函数实现的功能差不多，差别在于，flatMap有两个重载，一个强制解包去掉数组中nil元素，一个将二维数组降为一位数组。
(1). 遍历数组：
let numbers = [1, 2, 3, 4, 5, 6, 7, 8]
let result = numbers.flatMap{$0} //[1, 2, 3, 4, 5, 6, 7, 8]
(2).数组降维
let numbers = [[1, 2, 3, 4], [5, 6, 7, 8]]
let result = numbers.flatMap{$0} //[1, 2, 3, 4, 5, 6, 7, 8]
let result2 = numbers.map{$0} //[[1, 2, 3, 4], [5, 6, 7, 8]]
(3).去掉数组中nil
let numbers = [1, 2, 3, 4, nil] //[Optional(1), Optional(2), Optional(3), Optional(4), nil]
let result = numbers.flatMap{$0} //[1, 2, 3, 4]去掉nil，解包输出
let result = numbers.map{$0} //[Optional(1), Optional(2), Optional(3), Optional(4), nil]
注意：
//非二维数组，数组不能和非数组合并
let numbers = [1, 2, 3, 4, [5, 6]] as [Any] //[1, 2, 3, 4, [5, 6]]
let result = numbers.flatMap{$0} //[1, 2, 3, 4, [5, 6]]
let result2 = numbers.map{$0} //[1, 2, 3, 4, [5, 6]]
//数组中的数组包含nil值，因为并不是数组和数组的操作，元素不会合并成一个数组，所以，数组中的数组不会被遍历，原样输出
let numbers = [1, 2, 3, 4, [5, 6, nil]] as [Any] //[1, 2, 3, 4, [Optional(5), Optional(6), nil]]
let result = numbers.flatMap{$0} //[1, 2, 3, 4, [Optional(5), Optional(6), nil]]
//因为数组元素其中一个为nil，去掉nil，解包输出
let numbers = [[1, 2, 3, 4], [5, 6], nil] //[Optional([1, 2, 3, 4]), Optional([5, 6]), nil]
let result = numbers.flatMap{$0} //[[1, 2, 3, 4], [5, 6]]
//数组包含两个数组和一个nil，去掉nil，解除最外层包输出
let numbers = [[1, 2, 3, 4], [5, 6, nil], nil] //[Optional([Optional(1), Optional(2), Optional(3), Optional(4)]), Optional([Optional(5), Optional(6), nil]), nil]
let result = numbers.flatMap{$0} //[[Optional(1), Optional(2), Optional(3), Optional(4)], [Optional(5), Optional(6), nil]]
//数组和数组合并
let numbers = [[1, 2], [3, 4, nil]] //[[Optional(1), Optional(2)], [Optional(3), Optional(4), nil]]
let result = numbers.flatMap{$0} //[Optional(1), Optional(2), Optional(3), Optional(4), nil]
由上面的例子，引出三个问题：
1.怎么去掉nil
2.怎么强行解包
3.如何将二维数组降维
先看一下flatMap的定义：
func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
func flatMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
去掉不相关的修饰词：
func flatMap<SegmentOfResult : Sequence>(_ transform: (Element) -> SegmentOfResult) -> [SegmentOfResult.Iterator.Element]
func flatMap<ElementOfResult>(_ transform: (Element) -> ElementOfResult?) -> [ElementOfResult]
第二个重载接收的闭包返回值是可选类型(Optional)，猜测去掉数组中的nil和解包操作都在这个重载；第一个重载接收闭包返回的是Sequence类型，可以把它看作是数组，那么二维数组降维应该调的是第一个重载，具体是不是正确的，继续深入看flatMap的源码实现：
flatMap第一个重载
@_inlineable
public func flatMap<SegmentOfResult : Sequence>(
_ transform: (${GElement}) throws -> SegmentOfResult
) rethrows -> [SegmentOfResult.${GElement}] {
var result: [SegmentOfResult.${GElement}] = []
for element in self {
result.append(contentsOf: try transform(element))
}
return result
}
flatMap接收的闭包返回值是Sequence，可以看成数组。重点代码：
result.append(contentsOf: try transform(element))
这个函数有什么作用呢？这个函数的作用就是把element数组里面的元素逐个取出来，然后添加到result数组的后面，这就是flatMap可以将二维数组降维成一维数组的原因，函数描述：
Adds the elements of a sequence to the end of the array.
举个例子：
var nums1 = [1, 2, 3, 4]
let nums2 = [5, 6, 7, 8, 9]
nums1.append(contentsOf: nums2) //[1, 2, 3, 4, 5, 6, 7 ,8, 9]
flatMap第二个重载
@_inlineable
public func flatMap<ElementOfResult>(
_ transform: (${GElement}) throws -> ElementOfResult?
) rethrows -> [ElementOfResult] {
var result: [ElementOfResult] = []
for element in self {
if let newElement = try transform(element) {
result.append(newElement)
}
}
return result
}
flatMap接收的闭包返回值是可选类型(Optional)，看一下关键代码：
for element in self {
if let newElement = try transform(element) {
result.append(newElement)
}
}
element就是数组里的每一个元素，"let newElement = transform(element)"，关键的一段代码，let常量不能为nil，所以，当transform(element)=nil，就被过滤掉了，并且newElement不是可选类型，所以，这里会解包赋值。
- reduce
Returns the result of combining the elements of the sequence using the given closure.
简单点来说就是联合处理数组的每个元素，举个例子求和：
let numbers = [1, 2, 3, 4, 5]
let sum = numbers.reduce(0, {$0+$1}) //15
//0是输入的初始值，$0，$1分别是闭包的第一个参数和第二个参数
不一定要求和，比如生成字符串：
let numbers = [1, 2, 3, 4, 5]
let sum = numbers.reduce("", {"\($0)\($1)"}) //"12345"
废话不多说，直接上源码：
@_inlineable
public func reduce<Result>(
_ initialResult: Result,
_ nextPartialResult:
(_ partialResult: Result, ${GElement}) throws -> Result
) rethrows -> Result {
var accumulator = initialResult
for element in self {
accumulator = try nextPartialResult(accumulator, element)
}
return accumulator
}
新生成一个变量accumulator，每次执行完闭包都把值赋给accumulator。闭包传进去的参数为上一次的值和当前数组元素，所以，我们可以将整个数组的值累加起来。
- filter
Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.
简单来说就是从一个数组筛选出符合条件的元素，以数组的形式返回。举个例子，筛选出<3的元素：
let numbers = [1, 2, 3, 4, 5]
let sum = numbers.filter{$0<3} //[1, 2]
3.总结
刚开始学习这些高阶函数，还挺难懂的，但是一旦懂了，就如虎添翼，用起来非常爽。
参考
Swift 烧脑体操（三） - 高阶函数
谈谈 Swift 中的 map 和 flatMap
Higher Order Functions: Map, Filter, Reduce and more
