Swift开发基础08-高阶函数-数字星空

高阶函数是指接受其它函数作为参数，或者返回其它函数的函数。Swift 提供了许多内置的高阶函数，这些函数在处理集合类型数据（如数组、集合等）时尤其有用。常见的高阶函数包括 map、filter、reduce、flatMap 和 compactMap。

一、常用高阶函数

1. `map`

map 函数会对集合中的每个元素应用一个相同的操作，并将结果聚合成一个新的集合。

示例：

假设我们有一个包含整数的数组，并希望将每个整数乘以2。

let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
print(doubled)  // 输出: [2, 4, 6, 8, 10]

2. `filter`

filter 函数会对集合中的每个元素进行条件判断，并返回符合条件的元素构成的新的集合。

示例：

我们有一个数组，需要过滤出所有的偶数。

let numbers = [1, 2, 3, 4, 5]
let evens = numbers.filter { $0 % 2 == 0 }
print(evens)  // 输出: [2, 4]

3. `reduce`

reduce 函数会将集合中的元素组合成一个值，通过应用一个累计的操作。它需要一个初始值和一个合并操作。

示例：

我们有一个数组，需要计算所有元素的总和。

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

4. `flatMap`

flatMap 会对多维集合进行扁平化操作，并将子集合中每一个元素应用特定的操作，然后返回一个新的集合。

示例：

我们有一个由数组组成的数组，需要将其展平成一个单一的数组。

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]

5. `compactMap`

compactMap 与 map 相似，但它会移除所有结果中的 nil 值。通常用于处理返回 Optional 的操作。

示例：

我们有一个字符串数组，希望将其转换为整数，但其中有些值无法转换。

let strings = ["1", "2", "three", "4", "five"]
let numbers = strings.compactMap { Int($0) }
print(numbers)  // 输出: [1, 2, 4]

6. 自定义高阶函数

除了 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 还提供了其他一些内置的高阶函数。

1. `forEach`

forEach 函数会对集合中的每一个元素执行指定的操作，但不会返回结果。它通常用作遍历集合的一个简洁替代。

示例：

let numbers = [1, 2, 3, 4, 5]
numbers.forEach { number in
    print(number)
}

2. `sorted` 和 `sort`

sorted 函数会返回一个排序后的新数组，而 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]

3. `contains`

contains 函数用于检查集合中是否包含某个元素。

示例：

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

4. `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
}

5. `allSatisfy`

allSatisfy 函数会检查集合中的所有元素是否都满足指定的条件。

示例：

let numbers = [2, 4, 6, 8, 10]
let allEven = numbers.allSatisfy { $0 % 2 == 0 }
print(allEven)  // 输出: true

6. `dropFirst` 和 `dropLast`

dropFirst 函数会移除集合的第一个元素，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]

7. `prefix` 和 `suffix`

prefix 函数会返回集合的前几个元素，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]

8. `zip`

zip 函数会合并两个集合，依次创建对应的元素对，形成一个新的序列。

示例：

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

9. `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]