深刻淺出Swift高階函數-Map、Filter、Reduce

Swift 做爲一門新興的語言，它吸取了衆多語言的優勢，函數式編程就是其中之一。在 Swift 中，函數是做爲一等公民的存在，因此學習高階函數仍是很是有必要的，它可使你的代碼擴展性更高，代碼更 Swift 範。廢話很少說，下面就讓咱們開始吧！

初探高階函數

在 Swift 中，高階函數一共有下面幾個：

• map：對給定數組每一個元素，執行閉包中的映射，將映射結果放置在數組中返回。
• flatMap：對給定數組的每一個元素，執行閉包中的映射，對映射結果進行合併操做，而後將合併操做後的結果放置在數組中返回。
• compactMap：對給定數組的每一個元素，執行閉包中的映射，將非空的映射結果放置在數組中返回。
• compactMap對給定數組的每一個元素，執行閉包中的映射，將非空的映射結果-鍵值對放置在字典中返回。
• filter：對給定數組的每一個元素，執行閉包中的操做，將符合條件的元素放在數組中返回。
• reduce：對給定數組的每一個元素，執行閉包中的操做對元素進行合併，並將合併結果返回。

經過上面的闡述，咱們大概瞭解到了這幾個函數是作什麼用的，下面咱們在經過幾個例子來具體看一下代碼上如何使用。

map

對於 map 函數，使用場景就是將數組的類型映射爲別的類型。好比，咱們有一個模型數組，模型的 id 字段咱們從服務器拿的是 String 類型，在某種場景下咱們須要轉爲 Int 類型，這時候咱們就能夠經過 map 函數來實現該需求。

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
}
複製代碼

compactMap

咱們將上面的代碼替換爲：

let intIds = stus.compactMap { (stu) in
    Int(stu.id)
}
複製代碼

這時，咱們再打印 intIds 就會發現它已經爲 Int 類型了。

compactMapValues

對於 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

對於 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()。

filter

這個函數就如同單詞的意思：查找。將符合條件的元素查找出來放置在數組中返回。好比咱們想查找年齡大於18歲的全部學生。

let adults = stus.filter { (stu) -> Bool in
    stu.age >= 18
}

print(adults) // 數組中只包含stu4 學生
複製代碼

reduce

對於 reduce，咱們的使用場景就是對數組中的元素進行組合運算，好比咱們想計算全部學生的年齡加載一塊兒是多少。

let totalAges = stus.reduce(0) { (result, stu) in
    return result + stu.age
}

print(totalAges) // 62
複製代碼

該函數的第一個參數爲初始值，後面元組中的第一個參數爲每次計算的結果，第二個參數爲每次遍歷的元素。最後將計算的結果返回。

組合使用

對於使用高階函數最大的好處就是能夠進行函數式編程了。下面咱們經過幾個小栗子來對這幾個高階函數進行組合使用。

將 String 類型映射爲 Int 類型，並查找id大於1002的全部學生

let adults = stus.compactMap { (stu) in
    Int(stu.id)
    }.filter { (id) -> Bool in
        id > 1002
}

print(adults) //[1003, 1004]
複製代碼

計算年齡大於12的全部學生年齡總和

let totalAge = stus.filter { (stu) -> Bool in
    stu.age > 12
    }.reduce(0) { (result, stu) in
        return result + stu.age
}

print(totalAge) // 50
複製代碼

本身動手實現上面的函數

經過上面的講述咱們知道了這幾個函數的工做原理，下面咱們來動手本身實現如下這幾個函數，加深一下對函數的理解。

下面的幾個函數只是實現一下大致思路，並無很細緻的實現官方函數的功能。

map

func customMap<T>(translate: (Element) -> T) -> [T] {
    var results = [T]()
    self.forEach { (ele) in
        results.append(translate(ele))
    }
    return results
}
複製代碼

compactMap

func customCompactMap<T>(translate: (Element) -> T?) -> [T] {
    var results = [T]()
    
    for ele in self {
        if let value = translate(ele) {
            results.append(value)
        }
    }
    return results
}
複製代碼

filter

func customFilter(condition: (Element) -> Bool) -> [Element] {
    var results = [Element]()
    
    self.forEach { (ele) in
        if condition(ele) {
            results.append(ele)
        }
    }
    return results
}
複製代碼

reduce

func customReduce<T>(initialvalue: T, produce:(T, Element) -> T) -> T {
    var total = initialvalue
    self.forEach { (ele) in
        total = produce(total, ele)
    }
    return total
}
複製代碼

總結

• 使用函數式編程不只能減小代碼的行數，還可以使用鏈式結構構建複雜的邏輯。
• 當你須要映射一個數組，而且不須要改變返回數組的層級結構的時候，使用 map ，反之，則使用 flatMap 。
• 當返回數組中的值必須非空的時候，使用 compactMap ；當返回字典中的鍵值對中的value 必須爲非空的時候，使用 compactMapValues 。
• 當你須要查詢的時候，使用 filter 。
• 當你須要將數組進行某種計算並返回一個值得時候，使用 reduce 。

思惟導圖：

參考連接

• Apple Document
• CompactMap vs flatMap: The differences explained
• A behind the scenes look at Map, Filter, and Reduce in Swift