一、函數(shù)式編程學習前的基礎(chǔ)知識
-
1.1、Array 的常見操作
-
map：映射的意思，它把數(shù)據(jù)進行循環(huán)，每次循環(huán)都會走大括號里面
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 }-
其他的實現(xiàn)方方式
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：設(shè)置初始值，返回值由初始值決定塘装，每次的結(jié)果與后面的元素結(jié)合做處理
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 結(jié)果(第一個值是reduce括號后面的值)急迂，element每個成員，最后的返回結(jié)果由reduce括號后面的值來決定的
- 還可以簡寫為：
var arr5 = arr.reduce(0, +)
-
map 與 flatMap 的區(qū)別
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 返回一個數(shù)組蹦肴，flatMap 把上述數(shù)組拆分掉
-
compactMap 在map的基礎(chǔ)上滿足條件僚碎，強制解包成功的才會被返回
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實現(xiàn)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的優(yōu)化
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----")打印結(jié)果如下勺阐，我們可以看到用到才會打印
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) 括號內(nèi)的就不會執(zhí)行
-
使用本場景二：為空的判斷
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 返回可選項 议忽，再經(jīng)過后面的
??不為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)
-
二懒闷、函數(shù)式編程
-
2.1、函數(shù)式編程(Funtional Programming栈幸，簡稱FP)
- 函數(shù)式編程(Funtional Programming愤估，簡稱FP)是一種編程范式，也就是如何編寫程序的方法論
- 主要思想:把計算過程盡量分解成一系列可復用函數(shù)的調(diào)用
- 主要特征:函數(shù)是“第一等公民”：函數(shù)與其他數(shù)據(jù)類型一樣的地位速址，可以賦值給其他變量玩焰，也可以作為函數(shù)參數(shù)、函數(shù)返回值
- 函數(shù)式編程最早出現(xiàn)在LISP語言壳繁，絕大部分的現(xiàn)代編程語言也對函數(shù)式編程做了不同程度的支持震捣，比如 Haskell荔棉、JavaScript闹炉、Python、Swift润樱、Kotlin渣触、Scala等
- 函數(shù)式編程中幾個常用的概念 pHigher-Order Function、Function Currying pFunctor壹若、Applicative Functor嗅钻、Monad
- 參考資料： 參考資料一皂冰、參考資料二
- 函數(shù)式編程(Funtional Programming愤估，簡稱FP)是一種編程范式，也就是如何編寫程序的方法論
-
2.2、FP 實踐-傳統(tǒng)寫法
假設(shè)要實現(xiàn)以下功能:[(num + 3) * 5 - 1] % 10 / 2var 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 實踐-函數(shù)式寫法
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)函數(shù)式寫法的好處：把計算過程盡量分解成一系列可復用函數(shù)的調(diào)用
-
比如上面的加法秃流，我們想要 1 與 很多的數(shù)相加，然后取出結(jié)果柳弄，如下舶胀，我們可以看到復用性很強
let fn = add(1) fn(2) // 1 與 2 相加 fn(3) // 1 與 3 相加 fn(4) // 1 與 4 相加 infix operator >>> : AdditionPrecedence是定義運算的方向A,B,C三種類型
-
-
2.3、高階函數(shù)(Higher-Order Function)
高階函數(shù)是至少滿足下列一個條件的函數(shù):接受一個或多個函數(shù)作為輸入(map碧注、filter嚣伐、reduce等)
-
返回一個函數(shù)
FP中到處都是高階函數(shù)，如下func add(_ v: Int) -> (Int) -> Int { { $0 + v } }
-
2.4萍丐、柯里化 ( Currying )
柯里化：將一個接受多參數(shù)的函數(shù)變換為一系列只接受單個參數(shù)的函數(shù)
柯里化轩端，如下-
2 個參數(shù)的柯里化
func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }上面的轉(zhuǎn)化為下面的，
v1是2逝变，$0是3func add(_ v1: Int) -> (Int) -> Int { { return $0 + v1 } } var num = add1(2)(3)提示：
Array基茵、Optional的map方法接收的參數(shù)就是一個柯里化函數(shù) -
3 個參數(shù)的柯里化
func add(_ v1: Int, _ v2: Int,_ v3: Int) -> Int { v1 + v2 + v3 }上面的轉(zhuǎn)化為下面的，
v1是2壳影，$0是3func 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耿导、柯里化版本自動轉(zhuǎn)換，如下
-
2個參數(shù)的柯里化版本自動轉(zhuǎn)換
func add1(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }轉(zhuǎn)換通式如下
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個參數(shù)的柯里化版本自動轉(zhuǎn)換
func add2(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 }轉(zhuǎn)換通式如下
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都是單子
-
