Swift 做爲一門新興的語言,它吸取了衆多語言的優勢,函數式編程就是其中之一。在 Swift 中,函數是做爲一等公民
的存在,因此學習高階函數仍是很是有必要的,它可使你的代碼擴展性更高,代碼更 Swift 範。廢話很少說,下面就讓咱們開始吧!編程
在 Swift 中,高階函數一共有下面幾個:swift
合併操做,
而後將合併操做後的結果放置在數組中返回。非空的
映射結果放置在數組中返回。非空的
映射結果-鍵值對放置在字典中返回。符合條件的元素
放在數組中返回。合併
,並將合併結果返回。經過上面的闡述,咱們大概瞭解到了這幾個函數是作什麼用的,下面咱們在經過幾個例子來具體看一下代碼上如何使用。數組
對於 map 函數,使用場景就是將數組的類型映射爲別的類型。好比,咱們有一個模型數組,模型的 id 字段咱們從服務器拿的是 String 類型,在某種場景下咱們須要轉爲 Int 類型,這時候咱們就能夠經過 map 函數來實現該需求。bash
struct Student {
let id: String
let name: String
let age: Int
}
let stu1 = Student(id: "1001", name: "stu1", age: 12)
let stu2 = Student(id: "1002", name: "stu2", age: 14)
let stu3 = Student(id: "1003", name: "stu3", age: 16)
let stu4 = Student(id: "1004", name: "stu4", age: 20)
let stus = [stu1, stu2, stu3, stu4]
let intIds = stus.map { (stu) in
Int(stu.id)
}
print(intIds) //[Optional(1001), Optional(1002), Optional(1003), Optional(1004)]
複製代碼
經過上述代碼,咱們將 id 字段從 String 映射爲了 Int? 類型,這並非咱們想要的 Int 類型。若是咱們須要訪問元素的話還得須要解包,那麼咱們如何既能將元素映射又能自動篩選 nil 的值呢?這時,就輪到 compactmap 出馬了。服務器
optional 也可使用map函數
閉包
var num: Int? = 2
let result = num.map {
$0 * 2
}
print(result) // Optional(4)
// ----而不是使用下面的代碼
var result: Int?
if let n = num {
result = n * 2
} else {
result = nil
}
複製代碼
咱們將上面的代碼替換爲:app
let intIds = stus.compactMap { (stu) in
Int(stu.id)
}
複製代碼
這時,咱們再打印 intIds 就會發現它已經爲 Int 類型了。函數式編程
對於 Set 和 Array ,你可使用 compactMap 來得到非空的集合,可是對於 Dictionary 來講,這個函數是不起做用的。函數
let dict = ["key1": 10, "key2": nil]
let result = dict.compactMap { $0 }
print(result) //[(key: "key1", value: Optional(10)), (key: "key2", value: nil)]
複製代碼
這時候,咱們須要使用 compactMapValues 函數來得到非空的字典。學習
let dict = ["key1": 10, "key2": nil]
let result = dict.compactMapValues { $0 }
print(result) //["key1": 10]
複製代碼
對於 flatMap,主要的應用場景就是你想得到一個單層集合的數組。經過下面的代碼來看一下 map 和 flapMap 的區別。
let scoresByName = ["Henk": [0, 5, 8], "John": [2, 5, 8]]
let mapped = scoresByName.map { $0.value }
// [[2, 5, 8], [0, 5, 8]]
print(mapped)
let flatMapped = scoresByName.flatMap { $0.value }
// [2, 5, 8, 0, 5, 8]
複製代碼
map 會直接將元素放在數組中,而 flatMap 會將元素平鋪在一個數組中。實際上,s.flatMap(transform)
等同於s.map(transform).joined()
。
這個函數就如同單詞的意思:查找。將符合條件的元素查找出來放置在數組中返回。好比咱們想查找年齡大於18歲的全部學生。
let adults = stus.filter { (stu) -> Bool in
stu.age >= 18
}
print(adults) // 數組中只包含stu4 學生
複製代碼
對於 reduce,咱們的使用場景就是對數組中的元素進行組合運算,好比咱們想計算全部學生的年齡加載一塊兒是多少。
let totalAges = stus.reduce(0) { (result, stu) in
return result + stu.age
}
print(totalAges) // 62
複製代碼
該函數的第一個參數爲初始值,後面元組中的第一個參數爲每次計算的結果,第二個參數爲每次遍歷的元素。最後將計算的結果返回。
對於使用高階函數最大的好處就是能夠進行函數式編程了。下面咱們經過幾個小栗子來對這幾個高階函數進行組合使用。
let adults = stus.compactMap { (stu) in
Int(stu.id)
}.filter { (id) -> Bool in
id > 1002
}
print(adults) //[1003, 1004]
複製代碼
let totalAge = stus.filter { (stu) -> Bool in
stu.age > 12
}.reduce(0) { (result, stu) in
return result + stu.age
}
print(totalAge) // 50
複製代碼
經過上面的講述咱們知道了這幾個函數的工做原理,下面咱們來動手本身實現如下這幾個函數,加深一下對函數的理解。
下面的幾個函數只是實現一下大致思路,並無很細緻的實現官方函數的功能。
func customMap<T>(translate: (Element) -> T) -> [T] {
var results = [T]()
self.forEach { (ele) in
results.append(translate(ele))
}
return results
}
複製代碼
func customCompactMap<T>(translate: (Element) -> T?) -> [T] {
var results = [T]()
for ele in self {
if let value = translate(ele) {
results.append(value)
}
}
return results
}
複製代碼
func customFilter(condition: (Element) -> Bool) -> [Element] {
var results = [Element]()
self.forEach { (ele) in
if condition(ele) {
results.append(ele)
}
}
return results
}
複製代碼
func customReduce<T>(initialvalue: T, produce:(T, Element) -> T) -> T {
var total = initialvalue
self.forEach { (ele) in
total = produce(total, ele)
}
return total
}
複製代碼
思惟導圖: