Swift中的高階函數功能作用範例詳解

2023-03-27 06:00:57

高階函數的作用

Swift中的高階函數是指那些引數或返回值是函數的函數。它們的存在使得我們可以用非常簡潔和優雅的程式碼來解決許多問題。

1. 簡化程式碼

高階函數的一大作用是簡化程式碼。例如，使用map函數可以對陣列中的所有元素進行相同的操作。

假設我們有一個儲存了一組整數的陣列，現在想要對所有的元素進行加法操作，例如將陣列中每個元素都加上10。如果沒有map函數，我們可能需要寫出如下程式碼：

var numbers = [1, 2, 3, 4, 5]
var result = [Int]()
for number in numbers {
    result.append(number + 10)
}
print(result) // 輸出 [11, 12, 13, 14, 15]

在上邊的程式碼中，我們使用迴圈遍歷了陣列，並對每個元素進行了加法操作，最終將結果儲存到了另一個陣列中。

使用map函數可以將上述程式碼簡化成一行程式碼：

let numbers = [1, 2, 3, 4, 5]
let result = numbers.map { $0 + 10 }
print(result) // 輸出 [11, 12, 13, 14, 15]

2. 提高可讀性

高階函數可以使得程式碼更容易理解和維護。例如，使用filter函數可以使得程式碼更加清晰地表達篩選的條件。

假設我們有一個儲存了一組商品的陣列，現在想要對商品進行篩選，只選擇價格大於等於100的商品，並且將它們的名稱儲存到一個新的陣列中。如果沒有filter函數，我們可能需要寫出如下程式碼：

var products = [
    Product(name: "iPhone", price: 999),
    Product(name: "iPad", price: 699),
    Product(name: "MacBook", price: 1499),
    Product(name: "iPod", price: 199)
]
var result = [String]()
for product in products {
    if product.price >= 100 {
        result.append(product.name)
    }
}
print(result) // 輸出 ["iPhone", "iPad", "MacBook", "iPod"]

在上邊的程式碼中，我們使用迴圈遍歷了商品陣列，對每個商品進行了價格判斷，並將符合條件的商品名稱儲存到了另一個陣列中。

使用filter函數可以將上述程式碼簡化成一行程式碼：

let products = [
    Product(name: "iPhone", price: 999),
    Product(name: "iPad", price: 699),
    Product(name: "MacBook", price: 1499),
    Product(name: "iPod", price: 199)
]
let result = products.filter { $0.price >= 100 }.map { $0.name }
print(result) // 輸出 ["iPhone", "iPad", "MacBook", "iPod"]

3. 支援函數語言程式設計

高階函數是函數語言程式設計的基石。使用高階函數可以將計算過程分解成獨立的函數塊，從而實現函數的組合和複用。例如，以map和filter函數為例，說明高階函數是如何實現函數的組合和複用的。

假設我們有一個儲存了一組數位的陣列，我們想要將每個數位平方，並將平方後的結果過濾出來，只保留那些大於10的數位。如果沒有高階函數，我們可能需要寫出如下程式碼：

let numbers = [1, 2, 3, 4, 5]
var squaredNumbers = [Int]()
for number in numbers {
    let squared = number * number
    if squared > 10 {
        squaredNumbers.append(squared)
    }
}
print(squaredNumbers) // 輸出 [16, 25]

上述程式碼中，我們使用迴圈遍歷了數位陣列，對每個數位進行了平方操作，並進行了判斷過濾操作，將符合條件的數位儲存到了另一個陣列中。

使用高階函數可以將上述程式碼簡化成幾行程式碼：

let numbers = [1, 2, 3, 4, 5]
let squaredNumbers = numbers.map { $0 * $0 }.filter { $0 > 10 }
print(squaredNumbers) // 輸出 [16, 25]

4. 提高程式碼的可重用性

高階函數可以讓我們抽象出通用的操作，從而讓同一個函數可以適用於不同的場景。例如，使用reduce函數可以將一個操作應用於一個陣列的所有元素，從而使得我們可以實現各種操作，例如求和、取最大值等等。

我們以求和為例說明reduce函數的應用：

假設我們有一個儲存了一組數位的陣列，我們想要求這組數位的和。如果沒有reduce函數，我們可能需要寫出如下程式碼：

let numbers = [1, 2, 3, 4, 5]
var sum = 0
for number in numbers {
    sum += number
}
print(sum) // 輸出 15

上述程式碼中，我們使用迴圈遍歷了數位陣列，並對每個數位進行了累加操作，得到最終的和。

使用reduce函數可以將上述程式碼簡化成一行程式碼：

let numbers = [1, 2, 3, 4, 5]
let sum = numbers.reduce(0, +)
print(sum) // 輸出 15

常見的高階函數

1. map()

map()函數接受一個閉包作為引數，並對序列中的每個元素應用該閉包，最終返回一個新的序列，其中包含閉包的返回值。例如：

let numbers = [1, 2, 3, 4, 5]
let squaredNumbers = numbers.map { $0 * $0 }
print(squaredNumbers) // [1, 4, 9, 16, 25]

2. filter()

filter()函數接受一個閉包作為引數，並返回一個新的序列，其中包含原序列中滿足閉包條件的元素。例如：

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

3. reduce()

reduce()函數接受一個閉包作為引數，並對序列中的所有元素進行迭代運算，最終返回一個合併後的值。例如：

let numbers = [1, 2, 3, 4, 5]
let sum = numbers.reduce(0) { $0 + $1 }
print(sum) // 15

4. sorted()

sorted()函數接受一個閉包作為引數，並返回一個新的序列，其中包含原序列按照閉包指定的排序方式排列後的元素。例如：

let numbers = [5, 2, 4, 1, 3]
let sortedNumbers = numbers.sorted { $0 &lt; $1 }
print(sortedNumbers) // [1, 2, 3, 4, 5]

5. forEach()

forEach()函數接受一個閉包作為引數，並對序列中的每個元素應用該閉包，但不返回任何值。例如：

let numbers = [1, 2, 3, 4, 5]
numbers.forEach { print($0) }
// 1
// 2
// 3
// 4
// 5

6. compactMap()

compactMap()函數接受一個閉包作為引數，並返回一個新的序列，其中包含原序列中不為nil的元素，通過閉包返回值的方式進行轉換。例如：

let numbers = ["1", "2", "3", "4", "5", "6"]
let evenNumbers = numbers.compactMap { Int($0) }.filter { $0 % 2 == 0 }
print(evenNumbers) // [2, 4, 6]

7. flatMap()

flatMap()函數接受一個閉包作為引數，並返回一個新的序列，其中包含原序列中通過閉包返回值的方式進行轉換後的所有元素。例如：

let numbers = [[1, 2], [3, 4], [5, 6]]
let flattenedNumbers = numbers.flatMap { $0 }
print(flattenedNumbers) // [1, 2, 3, 4, 5, 6]

8. zip()

zip()函數接受兩個序列作為引數，並返回一個新的序列，其中包含兩個序列中對應位置的元素進行組合後的元素。例如：

let numbers1 = [1, 2, 3]
let numbers2 = [4, 5, 6]
let zippedNumbers = zip(numbers1, numbers2).map { $0 + $1 }
print(zippedNumbers) // [5, 7, 9]

9. first()

first()函數接受一個閉包作為引數，並返回序列中符合閉包條件的第一個元素，如果沒有符合條件的元素則返回nil。例如：

let numbers = [1, 2, 3, 4, 5]
let firstEvenNumber = numbers.first { $0 % 2 == 0 }
print(firstEvenNumber) // Optional(2)

這裡的閉包接受一個元素作為引數，並返回一個Bool值來表示它是否符合條件。

10. contains()

contains()函數接受一個閉包作為引數，並返回一個Bool值，表示序列中是否存在符合閉包條件的元素。例如：

let numbers = [1, 2, 3, 4, 5]
let hasEvenNumber = numbers.contains { $0 % 2 == 0 }
print(hasEvenNumber) // true