rayjuneWu

To be a better man.

嗨，我是吴蕾君 (@rayjuneWu)，一名来自中国杭州的 iOS Developer / PM。

• 于  Swift

Swift：Map，FlatMap，Filter，Reduce指南

此文初始发布在我的简书。

Swift是支持一门函数式编程的语言，拥有Map，FlatMap,Filter,Reduce针对集合类型的操作。在使用Objective-C开发时，如果你没接触过函数式编程，那你可能没听说过这些名词，希望此篇文章可以帮助你了解Swift中的Map，FlatMap,Filter,Reduce。

Map

首先我们来看一下map在Swift中的的定义，我们看到它可以用在 Optionals 和 SequenceType 上（如：数组、词典等）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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操作

简要的说就是，如果这个可选值有值，那就解包，调用这个函数，之后返回一个可选值，需要注意的是，返回的可选值类型可以与原可选值类型不一致：

1
2
3
4
5
///原来类型： Int?,返回值类型：String?
var value:Int? = 1
var result = value.map { String("result = \($0)") }
/// "Optional("result = 1")"
print(result)
1
2
3
4
var value:Int? = nil
var result = value.map { String("result = \($0)") }
/// "nil"
print(result)
对SequenceType进行map操作

我们可以使用map方法遍历数组中的所有元素，并对这些元素一一进行一样的操作（函数方法）。map方法返回完成操作后的数组。

我们可以用For-in完成类似的操作：

1
2
3
4
5
6
7
8
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又会怎么样：

1
2
3
4
let results = values.map ({ (element) -> Int in
    return element * 2
})
//"[2, 6, 10, 14]"

我们向map传入了一个闭包，对数组中的所有元素都 乘以2，将返回的新的数组赋值为results，是不是精简了许多？还能更精简！

精简写法

1
2
let results = values.map { $0 * 2 }
//"[2, 6, 10, 14]"

what the fuck…沉住气，让我们一步步来解析怎么就精简成这样了，保证让你神清气爽。翻开The Swift Programming Language中对于闭包的定义你就能找到线索。

第一步：

由于闭包的函数体很短，所以我们将其改写成一行：

1
2
let results = values.map ({ (element) -> Int in return element * 2 })
//"[2, 6, 10, 14]"

第二步：

由于我们的闭包是作为map的参数传入的，系统可以推断出其参数与返回值，因为其参数必须是(Element) -> Int类型的函数。因此，返回值类型，->及围绕在参数周围的括号都可以被忽略：

1
2
let results = values.map ({ element  in return element * 2 })
//"[2, 6, 10, 14]"
第三步：

单行表达式闭包可以通过省略return来隐式返回闭包的结果：

1
2
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关键字也同样可以被省略：

1
2
let results = values.map ({ $0 * 2 })
//"[2, 6, 10, 14]"

例子中的$0即代表闭包中的第一个参数。

最后一步：

尾随闭包，由于我们的闭包是作为最后一个参数传递给map函数的，所以我们可以将闭包表达式尾随：

1
2
let results = values.map (){ $0 * 2 }
//"[2, 6, 10, 14]"

如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把()省略掉：

1
2
let results = values.map { $0 * 2 }
//"[2, 6, 10, 14]"

如果还有不明白的，可以多翻阅翻阅The Swift Programming Language。

FlatMap

与map一样，它可以用在 Optionals和 SequenceType 上（如：数组、词典等）。我们先来看看针对Optional的定义：

对 Optionals进行flatMap操作
1
2
3
4
5
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也就是在可选值层做了一个解包。

1
2
3
4
var value:String? = "1"
var result = value.map { Int($0)}
/// "Optional(Optional(1))"
print(result)

1
2
3
4
var value:String? = "1"
var result = value.flatMap { Int($0)}
/// ""Optional(1)"
print(result)

使用flatMap就可以在链式调用时，不用做额外的解包工作：

1
2
3
4
var value:String? = "1"
var result = value.flatMap { Int($0)}.map { $0 * 2 }
/// ""Optional(2)"
print(result)

对SequenceType进行flatMap操作

我们先来看看Swift中的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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的两个作用：

一：压平
1
2
3
var values = [[1,3,5,7],[9]]
let flattenResult = values.flatMap{ $0 }
/// [1, 3, 5, 7, 9]
二：空值过滤
1
2
3
var values:[Int?] = [1,3,5,7,9,nil]
let flattenResult = values.flatMap{ $0 }
/// [1, 3, 5, 7, 9]

Filter

同样，我先来看看Swift中的定义：

1
2
3
4
5
6
7
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)的闭包，来判断原数组中的元素是否符合条件，这个方法用来过滤数组中的一些元素再好不过了：

1
2
3
var values = [1,3,5,7,9]
let flattenResults = values.filter{ $0 % 3 == 0}
//[3, 9]

我们向flatMap传入了一个闭包，筛选出了能被3整除的数据。

Reduce

我们先来看下Swift中的定义：

1
2
3
4
5
6
7
8
9
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值。来看下面的代码（为了更方便你理解这个过程，代码就不简写了）：

1
2
3
4
5
6
7
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所做的操作是等价的：

1
2
3
4
5
6
func combine(tempResult: Int, element: Int) -> Int  {
    return tempResult + element
}
reduceResult = combine(combine(combine(initialResult, element: 1), element: 3), element: 5)
print(reduceResult)
//9

以上所用的一些示例代码可以在我的Github中找到，如果您有什么建议可以在评论区留言。

最近的文章

Xcode8兼容Swift2.3项目

如果你最近升级了Xcode8，一跑Swift2.3的项目，毫无意外地，都是错误。希望看完这篇文章，可以帮你顺利跑起来。 Xcode8同时支持Swift2.3与Swift3.0,你可以自由选择使用其一来开发。Swift3.0刚刚出来不久(当前2016-09-19),公司项目使用的部分第三方库还没有Sw …

• 于  Swift 继续阅读
更早的文章

Swift2-同时解包多个可选值（Optionals）

话不多说，直接上代码 方式1：123456var optional1: String?var optianal2: String?if let optional1 = optional1, optianal2 = optianal2 &#123;    &#125; 看起来很美~问题来了：如果我希望 …

• 于  Swift 继续阅读
comments powered by Disqus