Map、Filter和Reduce

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 的效率显然会更高。理论上，编译器可以优化代码，使其速度与可变结果数组的版本一样快