一个函数接受一些输入，对它做一些事情并创建一个输出。功能有签名和正文。如果为函数提供相同的输入，则始终获得相同的输出。简而言之，这是函数的定义。
现在我们将通过仔细研究它们来讨论更多功能。我们将在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扩展中实现泛型函数，如下所示：
- 在Array Extension中声明一个map函数，它使用泛型类型T.
- 该函数采用类型（元素） - > T的函数作为输入
- 声明一个空结果数组，该数组在函数内部保存T类型的数据。
- 实现for循环迭代自身并调用transform函数将元素转换为T类型
- 将转换后的值附加到结果数组中
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循环内部以更新结果变量。
