即使早在 Swift 正式发布之前，iOS / Cocoa 开发者都可以使用诸如 ObjectiveSugar 或者 ReactiveCocoa 第三方库，实现类似map、flatMap或filter等函数式编程的构建。而在 Swift 中，这些家伙（map等几个函数）已经入驻成为「头等公民」了。比起标准的for循环，使用函数式编程有很多优势。它们通常能够更好地表达你的意图，减少代码的行数，以及使用链式结构构建复杂的逻辑，更显清爽。
本文中，我将介绍附加于 Swift 中的一个非常酷的函数：「Reduce」。相对于map/filter函数，reduce有时不失为一个更好的解决方案。
一个简单的问题
思考这么一个问题：你从 JSON 中获取到一个 persons 列表，意图计算所有来自 California 的居民的平均年龄。需要解析的数据如下所示：
let persons: [[String: String]] = [["name": "Carl Saxon","city": "New York,NY","age": "44"],["name": "Travis Downing","city": "El Segundo,CA","age": "34"],["name": "Liz Parker","city": "San Francisco,"age": "32"],["name": "John Newden","city": "New Jersey,"age": "21"],["name": "Hector Simons","city": "San Diego,"age": "37"],["name": "Brian Neo","age": "27"]] //注意这家伙没有 city 键值
注意最后一个记录，它遗漏了问题中 person 的居住地 city 。对于这些情况，默默忽略即可…
本例中，我们期望的结果是那三位来自 California 的居民。让我们尝试在 Swift 中使用flatMap和filter来实现这个任务。使用flatMap函数替代map函数的原因在于前者能够忽略可选值为 nil 的情况。例如flatMap([0,nil,1,2,nil])的结果是[0,2]。处理那些没有 city 属性的情况这会非常有用。
func infoFromState(state state: String,persons: [[String: AnyObject]])
-> Int {
// 先进行 flatMap 后进行 filter 筛选
// $0["city"] 是一个可选值，对于那些没有 city 属性的项返回 nil
// componentsSeparatedByString 处理键值，例如 "New York,NY"
// 最后返回的 ["New York","NY"]，last 取到最后的 NY
return persons.flatMap( { $0["city"] })
.filter({$0.hasSuffix(state)})
.count
}
infoFromState(state: "CA",persons: persons)
//#+RESULTS:
//: 3
这非常简单。
不过，现在来思考另外一个难题：你想要获悉居住在 California 的人口数，接着计算他们的平均年龄。如果我们想要在上面函数的基础上尝试做修改，立马会发现难度不小。解决方法倒是有几种，不过大都看起来不适用函数式结构解决方案。倒是通过循环的方式能简单的解决这个问题。
这时候我们要琢磨为啥不适用了，原因很简单：数据的形式（Shape）改变了。而map、filter函数能够始终保持数据形式的相似性。数组传入，数组返回。当然数组的元素个数和内容可以改变，不过始终是数组形式（Array-shape）。但是，上面所描述的问题要求我们最后转换成的结果是个结构体（Struct），或者说是以元组（Tuple）的形式包含一个整型平均值（平均年龄）和一个整型总和（人口数）。
对于这种类型的问题，我们可以使用reduce来救场。
Reduce
Reduce 是flatMap或filter的一种扩展的形式（译者注：后三个函数能干嘛，reduce 就能用另外一种方式实现）。Reduce的基础思想是将一个序列转换为一个不同类型的数据，期间通过一个累加器（Accumulator）来持续记录递增状态。为了实现这个方法，我们会向 reduce 方法中传入一个用于处理序列中每个元素的结合（Combinator）闭包 / 函数 / 方法。这听起来有点复杂，不过通过几个例子练手，你就会发现这相当简单。
它是SequenceType中的一个方法，看起来是这样的（简化版本）：
func reduce<T>(initial: T,combine: (T,Self.Generator.Element) -> T) -> T |
此刻，我们拥有一个初始值（Initial value）以及一个闭包（返回值类型和初始值类型一致）。函数最后的返回值同样和初始值类型一致，为T。
假设我们现在要实现一个 reduce 操作 — 对一个整数列表值做累加运算，方案如下：
return accumulator + current
}
[1,2,31);">3].reduce(0,combine: combinator)
// 执行步骤如下
combinator(1) { return 0 + 1 } = 1
combinator(2) { 1 + 2 } = 3
combinator(3,31);">3) { 3 + 3 } = 6
= 6
[1,3]中的每个元素都将调用一次结合（Combinator）函数进行处理。同时我们使用累加器（Accumulator）变量实时记录递增状态（递增并非是指加法），这里是一个整型值。
接下来，我们重新实现那些函数式编程的「伙伴」（自己来写 map、flatMap 和 filter 函数）。简便起见，所有这些方法都是对Int或Optional<Int>进行操作的；换言之，我们此刻不考虑泛型。另外牢记下面的实现只是为了展示reduce的实现过程。原生的 Swift 实现相比较下面 reduce 的版本，速度要快很多1。不过，Reduce 能在不同的问题中表现得很好，之后会进一步地详述。
Map
rmap(elements: [Int],transform: (Int) -> Int) -> [Int] {
return elements.reduce([Int](),combine: { (var acc: [Int],obj: Int) -> [Int] in
acc.append(transform(obj))
return acc
})
}
print(rmap([4],transform: { $0 * 2}))
// [2,4,6,8]
这个例子能够很好地帮助你理解reduce的基础知识。
- 首先，elements 序列调用 reduce 方法：
elements.reduce...。 - 然后，我们传入初始值给累加器（Accumulator），即一个 Int 类型空数组（
[Int]()）。 - 接着，我们传入
combinator闭包，它接收两个参数：第一个参数为 accumulator，即acc: [Int]；第二个参数为从序列中取得的当前对象obj: Int（译者注：对序列进行遍历，每次取到其中的一个对象 obj）。 combinator闭包体中的实现代码非常简单。我们对 obj 做变换处理，然后添加到累加器 accumulator 中。最后返回 accumulator 对象。
相比较调用map方法，这种实现代码看起来有点冗余。的确如此！但是，上面这个版本相当详细地解释了reduce方法是怎么工作的。我们可以对此进行简化。
// $0 表示第一个传入参数，$1 表示第二个传入参数，依次类推...
0 + [transform($1)]})
}
依旧能够正常运行。这个版本都有哪些不同呢？实际上，我们使用了 Swift 中的小技巧，
+运算符能够对两个序列进行加法操作。因此这里有个地方需要引起注意：。倘若你正在处理庞大的列表，应取代集合 + 集合的方式，转而使用一个可变的 accumulator 变量进行递增：
var ac: [Int],b: Int) -> [Int] in // 作者提倡使用这种，因为执行速度更快
ac.append(transform(b))
return ac
})
}
为了进一步加深对reduce的理解，我们将继续重新实现filter方法。
combine: { guard let m = transform($1) else { return $0 }
0 + [m]})
}
print(rflatMap([guard $0 != 3 return nil }; 这里 rflatMap 和 rmap 主要差异在于，前者增加了一个
guard表达式确保可选类型始终有值（换言之，摒弃那些 nil 的情况）。
Filter
guard filter($0 + [$1]})
}
print(rFilter([4,31);">6],filter: { $0 % 2 == 0}))
// [4,6]
依旧难度不大。我们再次使用 guard 表达式确保满足筛选条件。
到目前为止，reduce方法看起来更像是map或filter的复杂版本，除此之外然并卵。不过，所结合的内容不需要是一个数组，它可以是其他任何类型。这使得我们依靠一种简单的方式，就可以轻松地实现各种 reduction 操作。
Reduce 范例
首先介绍我最喜欢的数组元素求和范例：
[4].// 10
仅传入+作为一个combinator函数是有效的，它仅仅是对lhs（Left-hand side，等式左侧）和rhs（Right-hand side，等式右侧）做加法处理，最后返回结果值，这完全满足reduce函数的要求。
另外一个范例：通过一组数字计算他们的乘积：
[// 24
甚至我们可以反转数组：
[5].1] + $0 })
// 5,3,1
最后，来点有难度的任务。我们想要基于某个标准对列表做划分（Partition）处理：
typealias Acc = (l: [Int],r: [Int])
partition(lst: [Int],criteria: (Int) -> Bool) -> Acc {
return lst.reduce((l: [Int](),r: [Int]()),combine: { (ac: Acc,o: Int) -> Acc in
if criteria(o) {
return (l: ac.l + [o],r: ac.r)
} else {
return (r: ac.r + [o],l: ac.l)
}
})
}
partition([5,31);">6,31);">7,31);">8,31);">9],criteria: { $//: ([2,8],[1,5,7,9])
上面实现中最有意思的莫过于我们使用tuple作为 accumulator。你会渐渐发现，一旦你尝试将reduce进入到日常工作流中，tuple是一个不错的选择，它能够将数据与 reduce 操作快速挂钩起来。
执行效率对比：Reduce vs. 链式结构
reduce除了较强的灵活性之外，还具有另一个优势：通常情况下，map和filter所组成的链式结构会引入性能上的问题，因为它们需要多次遍历你的集合才能最终得到结果值，这种操作往往伴随着性能损失，比如以下代码：
除了毫无意义之外，它还浪费了 cpu 周期。初始序列（即 [0,4]）被重复访问了三次之多。首先是 map，接着 filter，最后对数组内容求和。其实，所有这一切操作我们能够使用reduce完全替换实现，极大提高执行效率：
[Int,r: Int) -> Int in
if (r + 3) % 0 {
return ac + r + 3
} else {
return ac
}
})
这里给出一个快速的基准运行测试，使用以上两个版本以及 for-loop 方式对一个容量为 100000 的列表做处理操作：
var ux = 0
for i in Array(0...100000) {
if (i + 0 {
ux += (i + 3)
}
}
正如你所看见的，reduce版本的执行效率和for-loop操作非常相近，且是链式操作的一半时间。
不过，在某些情况中，链式操作是优于reduce的。思考如下范例：
// 0.027 Seconds
ac.insert(r + 0)
return ac
}).// 2.927 Seconds
这里，注意到使用链式操作花费 0.027s，这与 reduce 操作的 2.927s 形成了鲜明的反差，这究竟是怎么回事呢？2
Reddit 网站的搜索结果指出，从 reduce 的语义上来说，传入闭包的参数（如果可变的话，即 mutated），会对底层序列的每个元素都产生一份 copy 。在我们的案例中，这意味着accumulator参数ac将为 0…100000 范围内的每个元素都执行一次复制操作。有关对此更好、更详细的解释请看这篇Airspeedvelocity博客文章。
因此，当我们试图使用reduce来替换掉一组操作时，请时刻保持清醒，问问自己：reduction 在问题中的情形下是否确实是最合适的方式。
现在，可以回到我们的初始问题：计算人口总数和平均年龄。请试着用reduce来解决吧。
再一次尝试来写 infoFromState 函数
func infoFromState(state state: String,persons: [[String: AnyObject]])
-> (count: Int,age: Float) {
// 在函数内定义别名让函数更加简洁
typealias Acc = (count: Int,age: Float)
// reduce 结果暂存为临时的变量
let u = persons.reduce((count: 0,age: 0.0)) {
(ac: Acc,p) -> Acc in
// 获取地区和年龄
guard let personState = p["city"],personAge = p["age"]
// 确保选出来的是来自正确的洲
where personState.hasSuffix(state)
// 如果缺失年龄或者地区，又或者上者比较结果不等，返回
else { return ac }
// 最终累加计算人数和年龄
return (count: ac.count + 1,age: ac.age + Float(personAge))
}
// 我们的结果就是上面的人数和除以人数后的平均年龄
return (age: u.age / Float(u.count),count: u.count)
}
print(infoFromState(state: "CA",persons: persons))
// prints: (count: 3,age: 34.3333)
和早前的范例一样，我们再次使用了tuple作为 accumulator 记录状态值。除此之外，代码读起来简明易懂。
同时，我们在函数体中定义了一个别名Acc：typealias Acc = (count: Int,age: Float)，起到了简化类型注释的作用。
总结
本文是对reduce方法的一个简短概述。倘若你不想将过多函数式方法通过链式结构串联起来调用，亦或是数据的输出形式与传入数据的形式不一致时，reduce 就相当有用了。最后，我将向你展示通过使用 reduce 的各种范例来结束本文，希望能为你带来些许灵感。
更多范例
以下范例展示了reduce的其他使用案例。请记住例子只作为展示教学使用，即它们更多地强调 reduce 的使用方式，而非为你的代码库提供通用的解决方法。大多数范例都可以通过其他更好、更快的方式来编写（即通过 extension 或 generics）。并且这些实现方式已经在许多 Swift 库中都有实现，诸如SwiftSequence以及Dollar.swift
Minimum
返回列表中的最小项。显然，方法更胜一筹。
// min 闭包传入两个参数：1. 初始值 2. 遍历列表时的当前元素
// 倘若当前元素小于初始值，初始值就会替换成当前元素
// 示意写法： initial = min(initial,elem)
[9,31);">reduce(Int.max,combine: min)
Unique
剔除列表中重复的元素。当然，最好的解决方式是使用集合（Set）。
if a.contains(b) {
return a
} else {
return a + [b]
}
})
// prints: 1,7
Group By
遍历整个列表，通过一个鉴别函数对列表中元素进行分组，将分组后的列表作为结果值返回。问题中的鉴别函数返回值类型需要遵循Hashable协议，这样我们才能拥有不同的键值。此外保留元素的排序，而组内元素排序则不一定被保留下来。
return items.reduce([:],168);">var ac: [H: [T]],o: T) -> [H: [T]] in
// o 为遍历序列的当前元素
let h = f(o) // 通过 f 函数得到 o 对应的键值
if var c = ac[h] { // 说明 o 对应的键值已经存在，只需要更新键值对应的数组元素即可
c.append(o)
ac.updateValue(c,forKey: h)
} else { // 说明 o 对应的键值不存在，需要为字典新增一个键值，对应值为 [o]
ac.updateValue([o],forKey: h)
}
return ac
})
}
print(groupby([10,31);">11,31);">12],f: { $3 }))
// prints: [2: [2,8,11],0: [3,12],1: [1,10]]
print(groupby(["Carl","Cozy",0);">"Bethlehem",0);">"Belem",0);">"Brand",0);">"Zara"],31);">0.characters.first! }))
// prints: ["C" : ["Carl","Cozy"],"B" : ["Bethlehem","Belem","Brand"],"Z" : ["Zara"]]
Interpose
函数给定一个items数组，每隔count个元素插入element元素，返回结果值。下面的实现确保了 element 仅在中间插入，而不会添加到数组尾部。
// cur 为当前遍历元素的索引值 cnt 为计数器，当值等于 count 时又重新置 1
typealias Acc = (ac: [T],cur: Int,cnt: Int)
reduce((ac: [],cur: 1),combine: { (a: Acc,o: T) -> Acc in
switch a {
// 此时遍历的当前元素为序列中的最后一个元素
case let (ac,cur,31);">_) where (cur+1) == items.count: return (ac + [o],31);">0)
// 满足插入条件
c) where c == count:
return (ac + [o,element],cur + 1)
// 执行下一步
c):
c + 1)
}
}).ac
}
print(interpose([5],element: 9))
// : [1,5]
count: 2))
该函数允许你有选择从两个序列中挑选元素合并成为一个新序列返回。
// Zip2Sequence 返回 [(list1,list2)] 是一个数组，类型为元组
// 也就解释了为什么 combinator 闭包的类型是 (ac: [T],o: (T,T)) -> [T]
return Zip2Sequence(list1,list2).T],o: (T,T)) -> [T] in
return ac + [o.1]
})
}
print(interdig([6]))
Chunk
该函数返回原数组分解成长度为n后的多个数组：
typealias Acc = (stack: [[T]],cur: [T],168);">let l = list.reduce((stack: [],cur: [],31);">0),168);">in
if ac.cnt == length {
return (stack: ac.stack + [ac.cur],cur: [o],31);">1)
} else {
return (stack: ac.stack,cur: ac.cur + [o],cnt: ac.cnt + 1)
}
})
return l.stack + [l.cur]
}
print(chunk([7],length: // : [[1,2],[3,4],[5,6],[7]]
函数中使用一个更为复杂的accumulator，包含了 stack、current list 以及 count 。
译者注：有关 Reduce 底层实现，请看这篇文章。
原文http://swift.gg/2015/12/10/reduce-all-the-things/
原文链接：/swift/324332.html