高阶函数是指接受其它函数作为参数，或者返回其它函数的函数。Swift 提供了许多内置的高阶函数，这些函数在处理集合类型数据（如数组、集合等）时尤其有用。常见的高阶函数包括 map、filter、reduce、flatMap 和 compactMap。
mapmap 函数会对集合中的每个元素应用一个相同的操作，并将结果聚合成一个新的集合。
假设我们有一个包含整数的数组，并希望将每个整数乘以2。
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
print(doubled) // 输出: [2, 4, 6, 8, 10]
filterfilter 函数会对集合中的每个元素进行条件判断，并返回符合条件的元素构成的新的集合。
我们有一个数组，需要过滤出所有的偶数。
let numbers = [1, 2, 3, 4, 5]
let evens = numbers.filter { $0 % 2 == 0 }
print(evens) // 输出: [2, 4]
reducereduce 函数会将集合中的元素组合成一个值，通过应用一个累计的操作。它需要一个初始值和一个合并操作。
我们有一个数组，需要计算所有元素的总和。
let numbers = [1, 2, 3, 4, 5]
let sum = numbers.reduce(0) { $0 + $1 }
print(sum) // 输出: 15
使用闭包语法可以简洁一点：
let sum = numbers.reduce(0, +)
print(sum) // 输出: 15
flatMapflatMap 会对多维集合进行扁平化操作，并将子集合中每一个元素应用特定的操作，然后返回一个新的集合。
我们有一个由数组组成的数组，需要将其展平成一个单一的数组。
let arrayOfArrays = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
let flattened = arrayOfArrays.flatMap { $0 }
print(flattened) // 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]
compactMapcompactMap 与 map 相似，但它会移除所有结果中的 nil 值。通常用于处理返回 Optional 的操作。
我们有一个字符串数组，希望将其转换为整数，但其中有些值无法转换。
let strings = ["1", "2", "three", "4", "five"]
let numbers = strings.compactMap { Int($0) }
print(numbers) // 输出: [1, 2, 4]
除了 Swift 提供的这些高阶函数，你也可以根据需要定义自己的高阶函数。
我们定义一个高阶函数，该函数接受一个过滤条件并返回符合条件的数组：
func customFilter<T>(array: [T], condition: (T) -> Bool) -> [T] {
var result = [T]()
for element in array {
if condition(element) {
result.append(element)
}
}
return result
}
let numbers = [1, 2, 3, 4, 5]
let evens = customFilter(array: numbers) { $0 % 2 == 0 }
print(evens) // 输出: [2, 4]
除了已经介绍的 map、filter、reduce、flatMap 和 compactMap 之外，Swift 还提供了其他一些内置的高阶函数。
forEachforEach 函数会对集合中的每一个元素执行指定的操作，但不会返回结果。它通常用作遍历集合的一个简洁替代。
let numbers = [1, 2, 3, 4, 5]
numbers.forEach { number in
print(number)
}
sorted 和 sortsorted 函数会返回一个排序后的新数组，而 sort 方法则会原地排序数组。
let numbers = [5, 3, 1, 4, 2]
let sortedNumbers = numbers.sorted()
print(sortedNumbers) // 输出: [1, 2, 3, 4, 5]
使用自定义排序规则：
let sortedDescending = numbers.sorted { $0 > $1 }
print(sortedDescending) // 输出: [5, 4, 3, 2, 1]
原地排序：
var numbers = [5, 3, 1, 4, 2]
numbers.sort()
print(numbers) // 输出: [1, 2, 3, 4, 5]
containscontains 函数用于检查集合中是否包含某个元素。
let numbers = [1, 2, 3, 4, 5]
let containsThree = numbers.contains(3)
print(containsThree) // 输出: true
或者使用自定义条件：
let hasEvenNumber = numbers.contains { $0 % 2 == 0 }
print(hasEvenNumber) // 输出: true
first(where:) 和 last(where:)first(where:) 函数会返回满足条件的第一个元素，last(where:) 会返回满足条件的最后一个元素。
let numbers = [1, 2, 3, 4, 5]
if let firstEven = numbers.first(where: { $0 % 2 == 0 }) {
print(firstEven) // 输出: 2
}
if let lastEven = numbers.last(where: { $0 % 2 == 0 }) {
print(lastEven) // 输出: 4
}
allSatisfyallSatisfy 函数会检查集合中的所有元素是否都满足指定的条件。
let numbers = [2, 4, 6, 8, 10]
let allEven = numbers.allSatisfy { $0 % 2 == 0 }
print(allEven) // 输出: true
dropFirst 和 dropLastdropFirst 函数会移除集合的第一个元素，dropLast 函数则会移除集合的最后一个元素。
let numbers = [1, 2, 3, 4, 5]
let withoutFirst = numbers.dropFirst()
print(withoutFirst) // 输出: [2, 3, 4, 5]
let withoutLast = numbers.dropLast()
print(withoutLast) // 输出: [1, 2, 3, 4]
prefix 和 suffixprefix 函数会返回集合的前几个元素，suffix 函数会返回集合的最后几个元素。
let numbers = [1, 2, 3, 4, 5]
let firstThree = numbers.prefix(3)
print(firstThree) // 输出: [1, 2, 3]
let lastTwo = numbers.suffix(2)
print(lastTwo) // 输出: [4, 5]
zipzip 函数会合并两个集合，依次创建对应的元素对，形成一个新的序列。
let names = ["Alice", "Bob", "Charlie"]
let ages = [25, 30, 35]
let combined = zip(names, ages)
for (name, age) in combined {
print("\(name) is \(age) years old")
}
// 输出:
// Alice is 25 years old
// Bob is 30 years old
// Charlie is 35 years old
reduce(into:)reduce(into:) 可以用来将集合的元素聚合成一个新集合，避免像 reduce 那样频繁地创建新值，从而提高性能。
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.reduce(into: [Int]()) { result, number in
result.append(number * 2)
}
print(doubled) // 输出: [2, 4, 6, 8, 10]
Swift 提供了丰富的内置高阶函数，这些函数极大地简化了对集合数据的处理，使代码更加简洁和功能性更强。通过灵活运用这些高阶函数，可以减少代码中的循环和条件判断，使代码更具可读性和维护性。了解并掌握这些高阶函数，可以帮助你编写更加简洁、高效和优雅的 Swift 代码。