一、Map , FlatMap , Filter , Reduce 指南
Swift是支持一门函数式编程的语言，拥有Map，FlatMap,Filter,Reduce针对集合类型的操作。在使用Objective-C开发时，如果你没接触过函数式编程，那你可能没听说过这些名词，希望此篇文章可以帮助你了解Swift中的Map，FlatMap,Filter,Reduce。
Map
首先我们来看一下map在Swift中的的定义，我们看到它可以用在 Optionals 和 SequenceType 上（如：数组、词典等）。
public enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible {
/// If `self == nil`, returns `nil`. Otherwise, returns `f(self!)`.
@warn_unused_result
public func map<U>(@noescape f: (Wrapped) throws -> U) rethrows -> U?
}
extension CollectionType {
/// Returns an `Array` containing the results of mapping `transform`
/// over `self`.
///
/// - Complexity: O(N).
@warn_unused_result
public func map<T>(@noescape transform: (Self.Generator.Element) throws -> T) rethrows -> [T]
}
@warn_unused_result：表示如果没有检查或者使用该方法的返回值，编译器就会报警告。
@noescape：表示transform这个闭包是非逃逸闭包，它只能在当前函数map中执行，不能脱离当前函数执行。这使得编译器可以明确的知道运行时的上下文环境（因此，在非逃逸闭包中可以不用写self），进而进行一些优化。
对 Optionals进行map操作
简要的说就是，如果这个可选值有值，那就解包，调用这个函数，之后返回一个可选值，需要注意的是，返回的可选值类型可以与原可选值类型不一致：
///原来类型： Int?,返回值类型：String?
var value:Int? = 1
var result = value.map { String("result = \($0)") }
/// "Optional("result = 1")"
print(result)
var value:Int? = nil
var result = value.map { String("result = \($0)") }
/// "nil"
print(result)
对SequenceType进行map操作
我们可以使用map方法遍历数组中的所有元素，并对这些元素一一进行一样的操作（函数方法）。map方法返回完成操作后的数组。
我们可以用For-in完成类似的操作：
var values = [1,3,5,7]
var results = [Int]()
for var value in values {
value *= 2
results.append(value)
}
//"[2, 6, 10, 14]"
print(results)
这看起来有点麻烦，我们得先定义一个变量var results然后将values里面的元素遍历，进行我们的操作以后，将其添加进results，我们比较下使用map又会怎么样：
let results = values.map ({ (element) -> Int in
return element * 2
})
//"[2, 6, 10, 14]"
我们向map传入了一个闭包，对数组中的所有元素都 乘以2，将返回的新的数组赋值为results，是不是精简了许多？还能更精简！
精简写法
let results = values.map { $0 * 2 }
//"[2, 6, 10, 14]"
what the fuck...沉住气，让我们一步步来解析怎么就精简成这样了，保证让你神清气爽。翻开The Swift Programming Language中对于闭包的定义你就能找到线索。
第一步：
由于闭包的函数体很短，所以我们将其改写成一行：
let results = values.map ({ (element) -> Int in return element * 2 })
//"[2, 6, 10, 14]"
第二步：
由于我们的闭包是作为map的参数传入的，系统可以推断出其参数与返回值，因为其参数必须是(Element) -> Int类型的函数。因此，返回值类型，->及围绕在参数周围的括号都可以被忽略：
let results = values.map ({ element in return element * 2 })
//"[2, 6, 10, 14]"
第三步：
单行表达式闭包可以通过省略return来隐式返回闭包的结果：
let results = values.map ({ element in element * 2 })
//"[2, 6, 10, 14]"
由于闭包函数体只含有element * 2这单一的表达式，该表达式返回Int类型，与我们例子中map所需的闭包的返回值类型一致（其实是泛型），所以，可以省略return。
第四步：
参数名称缩写（Shorthand Argument Names），由于Swift自动为内联闭包提供了参数缩写功能，你可以直接使用$0,$1,$2...依次获取闭包的第1，2，3...个参数。
如果您在闭包表达式中使用参数名称缩写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。in关键字也同样可以被省略：
let results = values.map ({ $0 * 2 })
//"[2, 6, 10, 14]"
例子中的$0即代表闭包中的第一个参数。
最后一步：
尾随闭包，由于我们的闭包是作为最后一个参数传递给map函数的，所以我们可以将闭包表达式尾随：
let results = values.map (){ $0 * 2 }
//"[2, 6, 10, 14]"
如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把()省略掉：
let results = values.map { $0 * 2 }
//"[2, 6, 10, 14]"
如果还有不明白的，可以多翻阅翻阅The Swift Programming Language。
FlatMap
与map一样，它可以用在 Optionals和 SequenceType 上（如：数组、词典等）。我们先来看看针对Optional的定义：
对 Optionals进行flatMap操作
public enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible {
/// Returns `nil` if `self` is `nil`, `f(self!)` otherwise.
@warn_unused_result
public func flatMap<U>(@noescape f: (Wrapped) throws -> U?) rethrows -> U?
}
就闭包而言，这里有一个明显的不同，这次flatMap期望一个 (Wrapped) -> U?)闭包。对于可选值， flatMap 对于输入一个可选值时应用闭包返回一个可选值，之后这个结果会被压平，也就是返回一个解包后的结果。本质上，相比 map,flatMap也就是在可选值层做了一个解包。
var value:String? = "1"
var result = value.map { Int($0)}
/// "Optional(Optional(1))"
print(result)
var value:String? = "1"
var result = value.flatMap { Int($0)}
/// ""Optional(1)"
print(result)
使用flatMap就可以在链式调用时，不用做额外的解包工作：
var value:String? = "1"
var result = value.flatMap { Int($0)}.map { $0 * 2 }
/// ""Optional(2)"
print(result)
对SequenceType进行flatMap操作
我们先来看看Swift中的定义
extension SequenceType {
/// 返回一个将变换结果连接起来的数组
/// `transform` over `self`.
/// s.flatMap(transform)
/// is equivalent to
/// Array(s.map(transform).flatten())
@warn_unused_result
public func flatMap<S : SequenceType>(transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
}
extension SequenceType {
/// 返回一个包含非空值的映射变换结果
@warn_unused_result
public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]
}
通过这两个描述，就提现了flatMap对SequenceType的两个作用：
一：压平
var values = [[1,3,5,7],[9]]
let flattenResult = values.flatMap{ $0 }
/// [1, 3, 5, 7, 9]
二：空值过滤
var values:[Int?] = [1,3,5,7,9,nil]
let flattenResult = values.flatMap{ $0 }
/// [1, 3, 5, 7, 9]
Filter
同样，我先来看看Swift中的定义：
extension SequenceType {
/// 返回包含原数组中符合条件的元素的数组
/// Returns an `Array` containing the elements of `self`,
/// in order, that satisfy the predicate `includeElement`.
@warn_unused_result
public func filter(@noescape includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
}
filter函数接受一个(Element) -> Bool)的闭包，来判断原数组中的元素是否符合条件，这个方法用来过滤数组中的一些元素再好不过了：
var values = [1,3,5,7,9]
let flattenResults = values.filter{ $0 % 3 == 0}
//[3, 9]
我们向flatMap传入了一个闭包，筛选出了能被3整除的数据。
Reduce
我们先来看下Swift中的定义：
extension SequenceType {
/// Returns the result of repeatedly calling `combine` with an
/// accumulated value initialized to `initial` and each element of
/// `self`, in turn, i.e. return
/// `combine(combine(...combine(combine(initial, self[0]),
/// self[1]),...self[count-2]), self[count-1])`.
@warn_unused_result
public func reduce<T>(initial: T, @noescape combine: (T, Self.Generator.Element) throws -> T) rethrows -> T
}
给定一个初始化的combine结果，假设为result,从数组的第一个元素开始，不断地调用combine闭包，参数为：（result，数组中的元素)，返回的结果值继续调用combine函数，直至元素最后一个元素，返回最终的result值。来看下面的代码（为了更方便你理解这个过程，代码就不简写了）：
var values = [1,3,5]
let initialResult = 0
var reduceResult = values.reduce(initialResult, combine: { (tempResult, element) -> Int in
return tempResult + element
})
print(reduceResult)
//9
我们存在一个数组[1,3,5]，给定了一个初始化的结果 initialResult = 0，向reduce函数传了 (tempResult, element) -> Int的闭包，tempResut便是每次闭包返回的结果值，并且其初始值为我们之前设置的initialResult为0，element即为我们数组中的元素（可能为1,3,5）。reduce会一直调用combine闭包，直至数组最后一个元素。下面的代码更形象地描述了整个过程，这其实跟reduce所做的操作是等价的：
func combine(tempResult: Int, element: Int) -> Int {
return tempResult + element
}
reduceResult = combine(combine(combine(initialResult, element: 1), element: 3), element: 5)
print(reduceResult)
//9
作者：rayjuneWu
链接：https://www.jianshu.com/p/87b97dfbf17b
二、map，filter，reduce 实践
map：转换，可以对数组中的元素格式进行转换
//将Int数组转换为String数组
//$0代表数组的元素
let array = [1, 2, 3, 4, 5 , 6, 7]
let result = array.map{
String($0)
}
filter：过滤，可以对数组中的元素按照某种规则进行过滤
//在array中过滤出偶数
let result2 = array.filter{
$0 % 2 == 0
}
reduce：计算 ，可以对数组中的元素进行计算
//计算数组array元素的和
//在这里$0和$1的意义不同，$0代表元素计算后的结果，$1代表元素
//10代表初始化值，在这里可以理解为 $0初始值 = 10
let result3 = array.reduce(10){
$0 + $1
}
这三个函数介绍完了，可以看到这三个方法使用起来非常的便利，接下来我会写一个计算文件夹大小的Demo
之前我已经在沙盒中创建了log文件夹，里边存放了四个文件,我们要做的是计算出log文件夹下.pdf格式的文件大小。
先写两个方法分别获取文件夹的路径和计算一个文件的大小
//获取文件夹路径
func getFolderPath(folderName: String) -> String{
let path: NSString = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true).first!
return path.stringByAppendingPathComponent(folderName)
}
//计算一个文件的大小
func caculateFileSize(path: String) -> UInt64{
let fileManager = NSFileManager.defaultManager()
let dic: NSDictionary = try! fileManager.attributesOfItemAtPath(path)
let size = dic.fileSize()
return size
}
使用map，filter，reduce计算文件夹下.pdf格式文件大小
let folderPath = getFolderPath("log")
let childFiles = NSFileManager.defaultManager().subpathsAtPath(folderPath)
//使用filter过滤出.pdf格式的文件
//在map方法体中，将文件数组转换为size的数组
//使用reduce计算size数组的和
//最终返回reduce的计算结果
let result = childFiles?.filter{
($0.componentsSeparatedByString(".")).last == "pdf"
}.map({ (fileName) -> UInt64 in
let filePath = folderPath + "/" + fileName
return caculateFileSize(filePath)
}) .reduce(0){
$0 + $1
}
print(".pdf文件大小总和为----\(result)")
计算结果：
在代码中使用filter方法后直接调用了map方法，这是因为高阶函数支持链式调用，高阶函数的特性就是可以以一个函数或多个函数当参数，返回值也可以是一个函数，如果你使用过AutoLayout库 Masonry的话会很习惯这种写法。
以上仅代表我的个人观点，有不足的地方希望大家随时与我沟通
参考：
Swift 烧脑体操（三） - 高阶函数
Swift函数式编程实践
作者：Lilin_Coder
链接：https://www.jianshu.com/p/32c009fcb13d
