阅读 92

在幕后看看Swift中的Map,Filter和Reduce的实现

一个函数接受一些输入,对它做一些事情并创建一个输出。功能有签名和正文。如果为函数提供相同的输入,则始终获得相同的输出。简而言之,这是函数的定义。

现在我们将通过仔细研究它们来讨论更多功能。我们将在Swift中探索更高阶的函数。将另一个函数作为输入或返回函数的函数称为高阶函数。

在Swift中,我们使用Map,Filter,Reduce。当我们使用这些功能时,它似乎很神奇。此时,您可能不知道幕后发生了什么。通过函数式编程的思想和方法来映射,过滤和减少工作。即使Swift不是一种纯粹的功能语言,它也可以让你做功能性的东西。

现在让我们一个接一个地看一下背景中发生的事情。首先,我们将为某些特定数据类型实现这些函数的基本版本,然后我们将尝试实现通用版本。 ####Map 函数 假设我们有一个整数数组,我们需要编写一个函数,在向原始数组的每个元素添加一些delta值之后返回一个新数组。我们可以使用如下的简单for循环轻松地为此编写函数:


func increment(by delta: Int, to array: [Int]) -> [Int] {
    var result: [Int] = []
    for element in array {
        result.append(element + delta)
    }
    return result
}

increment(by: 2, to: arr) //[4, 5, 6, 7]
复制代码

现在我们需要另一个函数,它通过将原始数组的每个元素加倍来返回一个新数组。为此,我们可以像下面这样实现它:

var arr = [2, 3, 4, 5]

func square(_ array: [Int]) -> [Int]{
    var result: [Int] = []
    for element in array {
        result.append(element * element)
    }
    return result
}

square(arr) //[4, 9, 16, 25]
复制代码

如果我们看一下上面这两个函数,我们就可以发现它们基本上都在做同样的事情。只有for循环内部的功能不同。它们都将Integer数组作为输入,使用for循环转换每个元素,并返回一个新数组。所以基本上主要是将每个元素转换为新的元素。

由于Swift支持高阶函数,我们可以编写一个函数,它将获取一个整数数组,将函数转换为输入,并通过将transform函数应用于原始数组的每个元素来返回一个新数组。

var arr = [2, 3, 4, 5]

func apply(for array: [Int], transform: (Int) -> Int) -> [Int] {
    var result: [Int] = []
    for element in array {
        result.append(transform(element))
    }
    return result
}

apply(for: arr) { $0 * 3 } //[6, 9, 12, 15]
复制代码

但仍然存在以上问题:它只返回一个整数数组。例如,如果我们要求将输入整数数组转换为字符串数组,那么我们就不能用这个函数做到这一点。为此,我们需要编写适用于任何类型的通用函数。

func genericApply<T>(to array: [Int], transform: (Int) -> T) -> [T] {
    var result: [T] = []
    for element in array {
        result.append(transform(element))
    }
    return result
}

genericApply(to: arr) { String($0) } //["2", "3", "4", "5"]
复制代码

我们可以在Array扩展中实现泛型函数,如下所示:

  1. 在Array Extension中声明一个map函数,它使用泛型类型T.
  2. 该函数采用类型(元素) - > T的函数作为输入
  3. 声明一个空结果数组,该数组在函数内部保存T类型的数据。
  4. 实现for循环迭代自身并调用transform函数将元素转换为T类型
  5. 将转换后的值附加到结果数组中
var array = ["boudhayan", "biswas"]

extension Array {
    func map<T>(_ transform: (Element) -> T) -> [T] {
        var result: [T] = []
        for element in self {
            result.append(transform(element))
        }
        return result
    }
}

array.map { $0.count }  //[9, 6]
复制代码

这就是Map函数在Swift中的工作方式。如果我们需要实现map函数,那么我们将像上面一样实现它。所以基本上,它不会在数组中产生任何魔法 - 我们可以很容易地自己定义函数。 ##Filter函数 假设我们有一个整数数组,我们只想在数组中保留偶数。我们可以通过使用简单的lo来实现这一点。

let integers = [1, 2, 3, 4, 5, 6]

func evenIntegers(from array: [Int]) -> [Int] {
    var result: [Int] = []
    for element in array where element % 2 == 0 {
        result.append(element)
    }
    return result
}

evenIntegers(from: integers) //[2, 4 6]
复制代码

再一次,我们有一个表示项目类文件名的字符串数组,我们只想保留.swift文件。这也可以通过以下单循环完成:

let projectFiles = ["classA.swift", "classB.swift", ".gitignore", "ReadMe.md"]

func swiftFiles(from array: [String]) -> [String] {
    var result: [String] = []
    for element in array where element.hasSuffix(".swift") {
        result.append(element)
    }
    return result
}

swiftFiles(from: projectFiles) //["classA.swift", "classB.swift"]
复制代码

如果我们仔细研究上述两个函数的实现,那么我们就可以理解它们基本上做同样的事情 - 只有两个数组的数据类型不同。我们可以通过实现泛型过滤器函数来概括这一点,该函数将数组和函数作为输入,并且根据includeElement函数的输出,它决定是否在结果数组中添加元素。

extension Array {
    func filter(_ includeElement: (Element) -> Bool) -> [Element] {
        var result: [Element] = []
        for element in self where includeElement(element) {
            result.append(element)
        }
        return result
    }
}
复制代码

##Reduce函数 假设我们有一个整数数组,我们想要实现两个返回sum和元素乘积的函数。我们可以通过使用一个简单的for循环来实现它:

func sum(_ integers: [Int]) -> Int {
    var result = 0
    for element in integers {
        result += element
    }
    return result
}

func product(_ integers: [Int]) -> Int {
    var result = 1
    for element in integers {
        result *= element
    }
     return result
}

sum([1, 2, 3]) //6
product([2, 3, 4]) //24
复制代码

现在不是拥有一个整数数组,而是说我们有一个字符串数组,我们想要连接数组中的所有元素:

var names = ["Boudhayan", "Biswas"]

func concatenate(_ strings: [String]) -> String {
    var result = ""
    for element in strings {
        result += element
    }
    return result
}

concatenate(names) //BoudhayanBiswas
复制代码

这三个功能基本上都是一样的。它们将数组作为输入,初始化结果变量,迭代数组,并更新结果变量。

从这里我们可以实现一个适用于所有人的通用函数。为此,我们需要结果变量的初始值和在每次迭代中更新该变量的函数。

所以我们可以用以下定义实现泛型函数:

上述实现对于[Element]类型的任何输入数组都是通用的。它将计算类型T的结果。要工作,它需要类型T的初始值以分配给结果变量。然后,它需要一个类型(T,元素) - > T的函数,它将在每次迭代中用于for循环内部以更新结果变量。 #感谢阅读!

关注下面的标签,发现更多相似文章
评论