Swift5.0 - day11- 函數式編程

一、函數式編程學習前的基礎知識

  • 1.1、Array 的常見操作

    • map：映射的意思，它把數據進行循環，每次循環都會走大括號里面

      var arr = [1, 2, 3, 4]
print(arr) // [2, 4, 6, 8]
var arr2 = arr.map { $0 * 2 }
print(arr2) // [2, 4]

      提示：map的完整寫法如下

      var arr2 = arr.map { (a) -> Int in
       a * 2
}

      • 其他的實現方方式

        func double(_ i: Int) -> Int { i * 2 } 
var arr = [1, 2, 3, 4]
print(arr.map(double)) // [2, 4, 6, 8]

    • filter：過濾器，

      var arr = [1, 2, 3, 4]
var arr3 = arr.filter { $0 % 2 == 0 } 
print(arr3) [2, 4]

      提示：filter的完整寫法如下

      var arr3 = arr.filter { (a) -> Bool in
     a % 2 == 0
}

    • reduce：設置初始值，返回值由初始值決定，每次的結果與后面的元素結合做處理

      var arr = [1, 2, 3, 4]
var arr4 = arr.reduce(0) { $0 + $1 } // 10
print(arr4)

      提示：reduce的完整寫法如下

      var arr4 = arr.reduce(0) { (result, element) -> Int in
     result + element
}
      • result 結果(第一個值是reduce括號后面的值)，element每個成員，最后的返回結果由reduce括號后面的值來決定的
      • 還可以簡寫為：var arr5 = arr.reduce(0, +)

    • map 與 flatMap 的區別

      var arr = [1, 2, 3]
var arr2 = arr.map { Array.init(repeating: $0, count: 3) }
print(arr2) // [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
var arr3 = arr.flatMap { Array.init(repeating: $0, count: 3) }
print(arr3) // [1, 1, 1, 2, 2, 2, 3, 3, 3]

      提示：

      • map 返回一個數組，flatMap 把上述數組拆分掉

    • compactMap 在map的基礎上滿足條件，強制解包成功的才會被返回

      var arr = ["123", "test", "jack", "-30"]
print(arr)
var arr2 = arr.map { Int($0) }
print(arr2) // [Optional(123), nil, nil, Optional(-30)]
var arr3 = arr.compactMap { Int($0) }
print(arr3) // [123, -30]

    • 使用reduce實現map、filter的功能

      var arr = [1, 2, 3, 4]
// [2, 4, 6, 8]
print(arr.map { $0 * 2 })
print(arr.reduce([]) { $0 + [$1 * 2] })
// [2, 4]
print(arr.filter { $0 % 2 == 0 })
print(arr.reduce([]) { $1 % 2 == 0 ? $0 + [$1] : $0 })

      提示

  • 1.2、lazy 對map的優化

    let arr = [1, 2, 3]
let result = arr.lazy.map {
       (i: Int) -> Int in
    print("mapping \(i)")
    return i * 2
}

print("begin-----")
print("mapped", result[0])
print("mapped", result[1])
print("mapped", result[2])
print("end----")

    打印結果如下，我們可以看到用到才會打印

    begin-----
mapping 1
mapped 2
mapping 2
mapped 4
mapping 3
mapped 6
end----

  • 1.3、Optional 的 map 和 flatMap

    • map 返回的是可選項

      var num1: Int? = 10
var num2 = num1.map { $0 * 2 }  // Optional(20)
var num3: Int? = nil
var num4 = num3.map { $0 * 2 }  // nil

      提示：num1不為nil才會進入大括號進行做操作

    • flatMap 會比 map 聰明一點，如果包裝的是可選項，就不會再進行可選項包裝，如下 num3

      var num1: Int? = 10
var num2 = num1.map { Optional.some($0 * 2) }
print(num2) // Optional(Optional(20))
var num3 = num1.flatMap { Optional.some($0 * 2) }
print(num3) // Optional(20)

    • 使用本場景一：為空的判斷

      var fmt = DateFormatter()
fmt.dateFormat = "yyyy-MM-dd"
var str: String? = "2011-09-10"
// old
var date1 = str != nil ? fmt.date(from: str!) : nil
print(date1)
// new
var date2 = str.flatMap(fmt.date)
var date2 = str.flatMap { fmt.date(from: $0) }
print(date2)

      提示：str 如果為 nil, flatMap(fmt.date) 括號內的就不會執行

    • 使用本場景二：為空的判斷

      var score: Int? = 98
// old
var str1 = score != nil ? "socre is \(score!)" : "No score" 
// new
var str2 = score.map { "score is \($0)" } ?? "No score"

      提示：score.map 返回可選項 ，再經過后面的 ?? 不為nil的情況下進行解包為String

    • 使用本場景三：為空的判斷

      struct Person {
    var name: String
    var age: Int
}
var items = [
    Person(name: "jack", age: 20),
    Person(name: "rose", age: 21),
    Person(name: "kate", age: 22)
]

// old
func getPerson1(_ name: String) -> Person? {
    let index = items.firstIndex { $0.name == name }
    return index != nil ? items[index!] : nil
}

// new
func getPerson2(_ name: String) -> Person? {
    return items.firstIndex { $0.name == name }.map { items[$0] }
}

    • 使用本場景四：為空的判斷

      struct Person {
    var name: String
    var age: Int
    init?(_ json: [String : Any]) {
        guard let name = json["name"] as? String,
              let age = json["age"] as? Int else {
              return nil
        }
        self.name = name
        self.age = age
    }
}
var json: Dictionary? = ["name" : "Jack", "age" : 10] // old
var p1 = json != nil ? Person(json!) : nil
// new
var p2 = json.flatMap(Person.init)

二、函數式編程

  • 2.1、函數式編程(Funtional Programming，簡稱FP)

    • 函數式編程(Funtional Programming，簡稱FP)是一種編程范式，也就是如何編寫程序的方法論
      • 主要思想:把計算過程盡量分解成一系列可復用函數的調用
      • 主要特征:函數是“第一等公民”：函數與其他數據類型一樣的地位，可以賦值給其他變量，也可以作為函數參數、函數返回值
    • 函數式編程最早出現在LISP語言，絕大部分的現代編程語言也對函數式編程做了不同程度的支持，比如 Haskell、JavaScript、Python、Swift、Kotlin、Scala等
    • 函數式編程中幾個常用的概念 pHigher-Order Function、Function Currying pFunctor、Applicative Functor、Monad
    • 參考資料： 參考資料一、參考資料二

  • 2.2、FP 實踐-傳統寫法
    假設要實現以下功能: [(num + 3) * 5 - 1] % 10 / 2

    var num = 1

func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
func sub(_ v1: Int, _ v2: Int) -> Int { v1 - v2 }
func multiple(_ v1: Int, _ v2: Int) -> Int { v1 * v2 }
func divide(_ v1: Int, _ v2: Int) -> Int { v1 / v2 }
func mod(_ v1: Int, _ v2: Int) -> Int { v1 % v2 }

let result = divide(mod(sub(multiple(add(num, 3), 5), 1), 10), 2)
print(result)

  • 2.2、FP 實踐-函數式寫法

    var num = 1

func add(_ v: Int) -> (Int) -> Int { { $0 + v } }
func sub(_ v: Int) -> (Int) -> Int { { $0 - v } }
func multiple(_ v: Int) -> (Int) -> Int { { $0 * v } }
func divide(_ v: Int) -> (Int) -> Int { { $0 / v } }
func mod(_ v: Int) -> (Int) -> Int { { $0 % v } }
infix operator >>> : AdditionPrecedence
func >>><A, B, C>(_ f1: @escaping (A) -> B,
            _ f2: @escaping (B) -> C) -> (A) -> C { { f2(f1($0)) } }
var fn = add(3) >>> multiple(5) >>> sub(1) >>> mod(10) >>> divide(2)

let result = fn(num)
print(result)

    函數式寫法的好處：把計算過程盡量分解成一系列可復用函數的調用

    • 比如上面的加法，我們想要 1 與 很多的數相加，然后取出結果，如下，我們可以看到復用性很強

      let fn =  add(1)
fn(2)  // 1 與 2 相加
fn(3)  // 1 與 3 相加
fn(4)  // 1 與 4 相加

    • infix operator >>> : AdditionPrecedence 是定義運算的方向

    • A,B,C 三種類型

  • 2.3、高階函數(Higher-Order Function)
    高階函數是至少滿足下列一個條件的函數:

    • 接受一個或多個函數作為輸入(map、filter、reduce等)

    • 返回一個函數
      FP中到處都是高階函數，如下

      func add(_ v: Int) -> (Int) -> Int { { $0 + v } }

  • 2.4、柯里化 ( Currying )
    柯里化：將一個接受多參數的函數變換為一系列只接受單個參數的函數
    柯里化，如下

    • 2 個參數的柯里化

      func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }

      上面的轉化為下面的，v1 是 2 ，$0 是 3

      func add(_ v1: Int) -> (Int) -> Int { { return $0 + v1 } }
var num =  add1(2)(3)

      提示：Array、Optional 的 map 方法接收的參數就是一個柯里化函數

    • 3 個參數的柯里化

      func add(_ v1: Int, _ v2: Int,_ v3: Int) -> Int { v1 + v2 + v3 }

      上面的轉化為下面的，v1 是 2 ，$0 是 3

      func add(_ v1: Int) -> (Int) -> (Int) -> Int {
    return { v2 in
       return { v3 in
          return v1 + v2 + v3 
       }
    }
}
var num =  add(1)(2)(3)

      簡化為：func add(_ v1: Int) -> (Int) -> (Int) -> Int { { { }}}

  • 2.4、柯里化版本自動轉換，如下

    • 2個參數的柯里化版本自動轉換

      func add1(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }

      轉換通式如下

      func currying<A, B, C>(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C {
    { b in { a in fn(a, b) } }
}

      使用如下

      let curriedAdd1 = currying(add1)
print(curriedAdd1(10)(20))

    • 3個參數的柯里化版本自動轉換

      func add2(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 }

      轉換通式如下

      func currying<A, B, C, D>(_ fn: @escaping (A, B, C) -> D) -> (C) -> (B) -> (A) -> D {
     { c in { b in { a in fn(a, b, c) } } }
}

      使用如下

      let curriedAdd2 = currying(add2)
print(curriedAdd2(10)(20)(30))

  • 2.5、柯里化重載運算符

    func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
func sub(_ v1: Int, _ v2: Int) -> Int { v1 - v2 }
func multiple(_ v1: Int, _ v2: Int) -> Int { v1 * v2 }
func divide(_ v1: Int, _ v2: Int) -> Int { v1 / v2 }
func mod(_ v1: Int, _ v2: Int) -> Int { v1 % v2 }

prefix func ~<A, B, C>(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C { { b in { a in fn(a, b) } } }

infix operator >>> : AdditionPrecedence 
func >>><A, B, C>(_ f1: @escaping (A) -> B,
            _ f2: @escaping (B) -> C) -> (A) -> C { { f2(f1($0)) } }

    使用

    var num = 1
print((~add)(num)(5))

var fn2 = (~add)(3) >>> (~multiple)(5) >>> (~sub)(1) >>> (~mod)(10) >>> (~divide)(2)
print(fn2(num))

  • 2.6、函子( Functor )
    像Array、Optional這樣支持map運算的類型，稱為函子(Functor)

    // Array<Element>
public func map<T>(_ transform: (Element) -> T) -> Array<T>
// Optional<Wrapped>
public func map<U>(_ transform: (Wrapped) -> U) -> Optional<U>

  • 2.7、適用函子 ( Applicative Functor )

    • 對任意一個函子 F，如果能支持以下運算，該函子就是一個適用函子

      func pure<A>(_ value: A) -> F<A>
func <*><A, B>(fn: F<(A) -> B>, value: F<A>) -> F<B>

    • Optional可以成為適用函子

      func pure<A>(_ value: A) -> A? { value }
infix operator <*> : AdditionPrecedence
func <*><A, B>(fn: ((A) -> B)?, value: A?) -> B? {
     guard let f = fn, let v = value else { return nil }
     return f(v) 
}

var value: Int? = 10
var fn: ((Int) -> Int)? = { $0 * 2}
// Optional(20)
print(fn <*> value as Any)

    • Array可以成為適用函子

      func pure<A>(_ value: A) -> [A] { [value] }
func <*><A, B>(fn: [(A) -> B], value: [A]) -> [B] {
      var arr: [B] = []
      if fn.count == value.count {
           for i in fn.startIndex..<fn.endIndex {
               arr.append(fn[i](value[i]))
           } 
      }
      return arr 
}

// [10]
print(pure(10))

var arr = [{ $0 * 2}, { $0 + 10 }, { $0 - 5 }] <*> [1, 2, 3] // [2, 12, -2]
print(arr)

  • 2.8、單子( Monad )

    • 對任意一個類型 F，如果能支持以下運算，那么就可以稱為是一個單子(Monad)

      func pure<A>(_ value: A) -> F<A>
func flatMap<A, B>(_ value: F<A>, _ fn: (A) -> F<B>) -> F<B>

      很顯然，Array、Optional都是單子

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容