美文网首页Swift5.1语法学习
二十二、函数式编程、面向协议式编程

二十二、函数式编程、面向协议式编程

作者: 爱玩游戏的iOS菜鸟 | 来源:发表于2020-02-26 13:37 被阅读0次

    函数式编程（Functional Prigramming）

    函数式编程

    1. 函数式编程(Functional Prigramming,简称FP)是一种编程范式，也就是如何编写程序的方法论
    • 主要思想：把计算过程尽量分解成一系列可服用函数的调用
    • 主要特征：函数是"第一等公民"
      ✅函数与其他数据类型一样的地位，可以赋值给变量，也可以作为函数参数、函数返回值

    1. 函数式编程最早出现在LISP语言，绝大部分语言也对函数式编程做了不同程度的支持

    2. 函数式编程中几个常用的概念

    • Higher-Order Function、Function Currying
    • Functor、Applicative Functor、Monad
    1. 参考资料：
      函数式编程
      函数式编程
    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
}

//不仅嵌套多层 且难以理解
divide(mod(sub(multiple(add(num, 3), 5), 1), 10), 2)

    ✌️第二种写法：

    //函数式写法
func fp_add(_ v:Int) -> ((Int) -> Int){
    {
        $0 + v
    }
}

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

func fp_multiple(_ v:Int) -> ((Int) -> Int){
    {
        $0 * v
    }
}

func fp_divide(_ v:Int) -> ((Int) -> Int){
    {
        $0 / v
    }
}

func fp_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 = fp_add(3)>>>fp_multiple(5)>>>fp_sub(1)>>>fp_mod(1)>>>fp_mod(2)
fn(num)
    高阶函数
    1. 高阶函数至少满足下列一个条件的函数
    • 接受一个或多个函数作为输入(map,filter,reduce等)
    • 返回一个函数
    1. FB到处是高阶函数
    柯里化(Currying)
    • 将一个接受多个参数的函数变换为一系列只接受单个参数的函数
    func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
//调用 add(10,20) 顺序:10 + 20

func add(_ v: Int) -> (Int) -> Int { { $0 + v } }
//调用 add(20)(10) 顺序:先创建一个 X + 20 的函数 然后传10

    Tip：Array、Optional的map方法接收的参数就是一个柯里化函数

    三个数相加函数的Curring如下：

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

//柯⾥化
//v3 == 30
func add2(_ v3: Int) -> (Int) -> (Int) -> (Int) {
    //v2 == 20
    return { v2 in
        //v1 == 10
        return { v1 in
            return v3 + v2 + v1
        }
    }
}
add2(30)(20)(10) //10 + 20 + 30 = 60
    • 将函数柯里化
    //方法1：定义函数将原函数传入，内部柯里化
func add1(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
func add2(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 }

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

//传入一个函数，将函数柯里化
currying(add1)(20)(10) //add1(10,20) 10 + 20 = 30  20传给b，10传给a
currying(add2)(30)(20)(10) //add2(10,20,30) 10 + 20 + 30 = 60  30传给c，20传给b，10传给a

    //自定义运算符
func add(_ v1: Int, _ v2: Int, v3: Int) -> Int{
    v1 + v2 + v3
}

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

(~add)(30)(20)(10)

    再次回顾上面的例子(加减乘除):

    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
var fn = (~add)(3) >>> (~multiple)(5) >>> (~sub)(1) >>> (~mod)(10) >>> (~divide)(2)
fn(num) //[(num + 3) * 5 - 1] % 10 / 2
    函子(Functor)

    我们先看下面这个函数：

    func map<T>(_ fn: (Inner) -> T) -> Type<T>

    支持如上map运算的类型才能称为函子：

    1. map运算要支持泛型
    2. 要求接收一个函数，这个函数把Type内部存放的数据当作参数传进去，返回一个T
    3. 返回的也是同一种Type<T>类型

    因此Array、Optional也支持如上的运算即为函子

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

    如何去理解函子：

    如上该函子，函子里面包装的是2，对这个函子做+3的操作 函子解包取出里面的2，再将2做+3的操作，得到5，最后再将5又放到盒子里面，形成一个新的函子

    如果这个函子是可选类型，那么map就不会调用，那么+3操作就不会执行，如下图

    Optional类型

    如果是数组，里面存放的是2 4 6，先将2 4 6取出来分别做相应的操作，最后操作的结果再包装成数组

    Array类型
    适用函子

    对任意一个函子F，如果能支持以下运算，该函子就是一个适用函子

    func pure<A>(_ value: A) -> F<A> //可以理解为，随便给⼀个值就能返回⾃⼰类型的泛型
func <*><A, B>(fn: F<(A) -> B>, value: F<A>) -> F<B> //可以理解为，给⼀个泛型F<A>和⼀个泛型函数fn，最后返回⼀个泛型B
    1. 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}
print(fn <*> value as Any) //Optional(20)

    如何去理解适用函子：


    将需要计算的操作也进行包装
    适用函子
    1. Array是适用函子
    func pure<A>(_ value: A) -> [A] { [value] }

infix operator <*> : AdditionPrecedence

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
}

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

var arr = [{ $0 * 2}, { $0 + 10 }, { $0 - 5 }] <*> [1, 2, 3]
print(arr) // [2, 12, -2]
    单子（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都是单子

    面向协议式编程(Protocol Oriented Programming)

    面向协议编程
    • 面向协议编程（Protocol Oriented Programming，简称POP），是Swift的一种编程范式
    • Swift也是一门面向对象的编程语言（Object Oriented Programming，简称OOP）
    • 在Swift开发中，OOP和POP是相辅相成的，任何一方并不能取代另一方
    回顾OOP
    • OOP的三大特性：封装、继承、多态

    继承的经典使用场合：
    当多个类（比如A、B、C类）具有很多共性时，可以将这些共性抽取到一个父类中（比如D类），最后A、B、C类继承D类

    继承

    但是OOP也存在一些不足：如何将 BVC、DVC 的公共方法 run 抽取出来？

    如何基于OOP的解决方案？

    解决方案：

    1. 将run方法放到另一个对象A中，然后BVC、DVC拥有对象A属性
    • 缺点：多了一些额外的依赖关系
    1. 将run方法增加到UIViewController分类中
    • 缺点：UIViewController会越来越臃肿，而且会影响它的其他所有子类
    1. 将run方法抽取到新的父类，采用多继承？（OC无法做到，C++支持多继承）
    • 缺点：会增加程序设计复杂度，产生菱形继承等问题，需要开发者额外解决
    POP解决方案
    protocol Runnable {
    func run()
}

extension Runnable {
    func run() {
        print("run")
    }
}

class BVC: UIViewController, Runnable {}
class DVC: UITableViewController, Runnable {}
    POP的注意点
    • 优先考虑创建协议，而不是父类(基类)
    • 优先考虑值类型（struct、enum），而不是引用类型（class）
    • 巧用协议的扩展功能
    • 不要为了面向协议而使用协议
    利用协议实现前缀效果
    • 值类型
    //创建结构体
struct ZQ<Base> {
    let base: Base //Base是传⼊的类型
    init(_ base: Base) { //base是传⼊的类型的值
        self.base = base
    }
}

//创建协议，并给协议扩展类型和实例计算属性
protocol ZQCompatible {}
extension ZQCompatible {
    static var ll: ZQ<Self>.Type { //获取ZQ<Base>类型属性
        get { ZQ<Self>.self }
        set {}
    }
    
    var ll: ZQ<Self> {
    get { ZQ(self) } //获取ZQ<Base>实例属性
    set {}
    }
}

    extension String: ZQCompatible {}
extension NSString: ZQCompatible {}
extension ZQ where Base: ExpressibleByStringLiteral { //遵守这个协议的不是String就是NSString
    func numberCount() -> Int {
        let string = base as! String
        var count = 0
        for c in string where ("0"..."9").contains(c) {
            count += 1
        }
        return count
    }
    static func read(){
        print("read")
    }
}

//调用
var s1: String = "34DGF443454"
var s2: NSString = "34DGF443454"
var s3: NSMutableString = "34DGF443454"

//类型方法
String.ll.read()//输出：read

print(s1.ll.numberCount())//输出：8
print(s2.ll.numberCount())//输出：8
print(s3.ll.numberCount())//输出：8
    • 引用类型
    class Person {}
class Student: Person {}

//让Person遵守这个协议，并且给ZQ前缀扩充方法
extension Person: ZQCompatible {}
extension ZQ where Base: Person {
    func run() {}
    static func test() {}
}

Person.ll.test()
Student.ll.test()

let p = Person()
p.ll.run()

let s = Student()
s.ll.run()
    利用协议实现类型判断
    • 传入的是数组实例:
    func isArray(_ value: Any) -> Bool { value is [Any] }
isArray( [1, 2] ) //true
isArray( ["1", 2] ) //true
isArray( NSArray() ) //true
isArray( NSMutableArray() ) //true
    • 传入的是数组类型
    protocol ArrayType {}
extension Array: ArrayType {}
extension NSArray: ArrayType {}

func isArrayType(_ type: Any.Type) -> Bool { type is ArrayType.Type }
isArrayType([Int].self) //true
isArrayType([Any].self) //true
isArrayType(NSArray.self) //true
isArrayType(NSMutableArray.self) //true

    判断某个类型是否遵守某个协议：
    类型.self 即为 ArryType.Type
    [Int].self 即为 ArryType.Type

    相关文章

      网友评论

        本文标题：二十二、函数式编程、面向协议式编程

        本文链接：https://www.haomeiwen.com/subject/nyqexhtx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        Swift5.1语法学习

        关于我们|服务条款|联系我们|二十二、函数式编程、面向协议式编程|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！