Map
假设我们需要一个函数，她接受一个整型数组，通过计算得到返回一个新的数组
我们可以这样写
func incrementArray(xs: [Int]) -> [Int] {
var result: [Int] = []
for x in xs {
result.append(x + 1)
}
return result
}
假设我们现在需要生成一个每项都为参数数组对应项的两倍
func incrementArray1(xs: [Int]) -> [Int] {
var result: [Int] = []
for x in xs {
result.append(x * 2)
}
return result
}
在假设我们需要一个数组是字符串，每个字符串都添加一个,
func incrementArray2(xs: [String]) -> [String] {
var result: [String] = []
for x in xs {
result.append(x + ",")
}
return result
}
我们发现这几个处理基本都是相同的，但是每次变化参数类型，我们都需要重新写一个函数，我们这个时候就可以写一个泛型函数
func compute<T>(array:[T],transform:(T) -> T) -> [T] {
var result:[T] = []
for x in array {
result.append(transform(x))
}
return result
}
print(compute(array: [1,2,3], transform: {$0 * 2}))
为了每一次都方便调用，我们可以在Array中写一个extension
extension Array{
/// 数组转换，对数字的每一个元素进行转换，然后返回新的数组
/// - Parameter transform:转换类型
func map<T>(transform:(Element) -> T) -> [T] {
var result:[T] = []
for x in self {
result.append(transform(x))
}
return result
}
}
let arr = [1,2,3]
print(arr.map({$0 * 3}))
我们慢慢的就已经实现了map函数，在Swift标准库中已经实现了map函数
@inlinable public func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
Filter
假设我们有一个字符串组成的数组，代表文件夹内容
let exampleFiles = ["README.md", "HelloWorld.swift", "FlappyBird.swift"]
现在如果我们想要一个包含所有 .swift 文件的数组，可以很容易通过简单的循环得到
func getSwiftFiles(files: [String]) -> [String] {
var result: [String] = []
for file in files {
if file.hasSuffix(".swift") {
result.append(file)
}
}
return result
}
当然，我们可以将 getSwiftFiles 函数一般化。比如，相比于使用硬编码 (hardcoding) 的方式筛选扩展名为 .swift 的文件，传递一个附加的 String 参数进行比对会是更好的方法。我们接下来可以使用同样的函数去比对 .swift 或 .md文件。但是假如我们想查找没有扩展名的所有文件，或者是名字以字符串 Hello 开头的文件，那该怎么办呢
我们可以定义一个名为 filter 的通用型函数。就像之前看到的 map 那样，filter 函数接受一个函数作为参数。filter 函数的类型是 Element -> Bool —— 对于数组中的所有元素，此函数都会判定它是否应该被包含在结果中
extension Array{
func filter(includeElement:(Element) -> Bool) -> [Element] {
var result:[Element] = []
for x in self where includeElement(x) {
result.append(x)
}
return result
}
}
就像 map 一样，Swift 标准库中的数组类型已经有定义好的 filter 函数了
Reduce
在定义一个泛型函数来体现一个更常见的模式之前，我们会先考虑一些相对简单的函数
定义一个计算数组中所有整型值之和的函数非常简单：
func sum(xs: [Int]) -> Int {
var result: Int = 0
for x in xs {
result += x
}
return result
}
我们也可以使用类似 sum 中的 for 循环来定义一个 product 函数，用于计算所有数组项相乘之积：
func product(xs: [Int]) -> Int {
var result: Int = 1
for x in xs {
result = x * result
}
return result
}
同样地，我们可能想要连接数组中的所有字符串
func concatenate(xs: [String]) -> String {
var result: String = ""
for x in xs {
result += x
}
return result
}
这些函数有什么共同点呢？它们都将变量result初始化为某个值。随后对输入数组 xs 的每一项进行遍历，最后以某种方式更新结果。为了定义一个可以体现所需类型的泛型函数，我们需要对两份信息进行抽象：赋给result 变量的初始值，和用于在每一次循环中更新 result 的函数
考虑到这一点，我们得出了能够匹配此模式的 reduce 函数定义
extension Array {
func reduce<T>(initial: T, combine: (T, Element) -> T) -> T {
var result = initial
for x in self {
result = combine(result, x)
}
return result
}
}
这个函数的泛型体现在两个方面：对于任意 [Element] 类型的输入数组来说，它会计算一个类型为 T 的返回值。这么做的前提是，首先需要一个 T 类型的初始值 (赋给 result 变量)，以及一个用于更新 for 循环中变量值的函数 combine: (T, Element) -> T
【请务必注意】：尽管通过 reduce 来定义一切是个很有趣的练习，但是在实践中这往往不是一个什么好主意。原因在于，不出意外的话你的代码最终会在运行期间大量复制生成的数组，换句话说，它不得不反复分配内存，释放内存，以及复制大量内存中的内容。像我们之前做的一样，用一个可变结果数组定义 map 的效率显然会更高。理论上，编译器可以优化代码，使其速度与可变结果数组的版本一样快
