高阶函数介绍

1.map函数

（Return an Array containing the results of mapping transform）map函数对数组元素进行某种规则的转换并返回一个新的数组

let arr = [1,2,4,5]
let brr = arr.map {
    "No."+String($0)    将元素转换为字符串并拼接No.
    //$0+1     //将所有元素都加1
}
brr------>["No.1", "No.2", "No.4", "No.5"]

2.flatMap函数

flatMap函数有两种重载形式。这两个重载的函数都是接受一个闭包作为参数，返回一个数组。

public func flatMap(transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
(Self.Generator.Element) -> S，并且这里 S 被定义成：S : SequenceType。所以它是接受数组元素，然后输出一个 SequenceType 类型的元素的闭包
let arr1 = [[1,2,3],[6,5,4]]
let frr = arr1.flatMap {$0}     --->[1, 2, 3, 6, 5, 4]
let grr = Array(arr1.map { $0 }.flatten())   ---->[1, 2, 3, 6, 5, 4]

public func flatMap(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]
 flatMap 最终输出的数组结果，其实不是这个 T? 类型，而是这个 T? 类型解包之后，不为 .None 的元数数组：[T]
Return an `Array` containing the non-nil results of mapping 返回一个没有nil的map过的数组
let arr2:[Int?] = [1,2,nil,4,nil,5]
let hrr = arr2.flatMap {
    $0
}
hrr   ----->  [1, 2, 4, 5]
flatMap 将数组中nil都丢弃了。只保留非空的值

3.reduce函数

来对数组元素进行某种规则的求和（不一定是加和）
Return the result of repeatedly calling combine with an
accumulated value initialized to initial and each element of self, in turn

public func reduce(initial: T, @noescape combine: (T, Self.Generator.Element) throws -> T) rethrows -> T
initial:初始化的值，combine方法
let crr = arr.reduce(0) { (pre:Int, element:Int) -> Int in
    return pre+element
}
上例中initial=0,也就是从0开始用某种规则求和。
pre表示：之前求和的结果  ---> 一开始是0
element：表示即将进入运算的数组中的元素 ---->第一个是 1
pre+element：表示求和的规则    ---->闭包里面的规则自己定义

其他规则的求和

let drr = arr.reduce("") {
    if $0 == ""{
        return String($1)
    }else{
        return $0+" "+String($1)
    }
}
drr     ------>    "1 2 4 5"

4.filter函数

返回符合条件的元素的数组

 public func filter(@noescape includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]

let err = arr.filter { (num:Int) -> Bool in
    num%2==0   //需要符合的条件。
}
err  -----> [2, 4]