内容字号:默认大号超大号

段落设置:段首缩进取消段首缩进

字体设置:切换到微软雅黑切换到宋体

利用函数组合提升代码可维护性

2018-10-08 16:56 出处:清屏网 人气: 评论(0

前言

函数组合,在函数式编程里面也是挺重要的概念,能够将函数进行操作合并等,在有些场景下可以大幅度提升代码的可读及可维护性。

下面就演示一些利用函数组合重构代码以达到更好可维护性的例子

简单场景

假设有如下代码:

process1(_ param: String) -> String
process2(_ param: String) -> String
process3(_ param: String) -> String
process4(_ param: String) -> String

这些函数来处理字符串,如果要组合调用的话,可能会写出来如下的代码:

var str = ... 
str = process1(str) 
str = process2(str) 
str = process3(str) 
str = process4(str) 
// use str

或者更洒脱一些,写出如下的代码:

let ret = process4(process3(process2(process1(str))))

第二种方式可读性不算太好,第一种方式代码写起来又会非常繁琐。那应该如何来优化呢?

优化

Swift中是支持 自定义运算符 的,而且swift中 函数是一等公民 。这两个特性是很强大的,利用他们,可以更好的实现函数的组合,可以让代码看起来更简洁、更易读。

大概的思路是把process1、process2等进行组合,组合成一个新的函数,调用这个新函数的效果,跟分开挨个调用是一样的。

优化后的代码如下:

infix operator ++ : AdditionPrecedence
func ++ (lhs: @escaping (String) -> String, rhs: @escaping (String) -> String) -> (String) -> String {
    return { rhs(lhs($0)) }
}

let ret = (process1 ++ process2 ++ process3 ++ process4)(str)

这样写出来的代码,易读且易维护,要增删操作、调整调用顺序等都是很容易的。

更多场景

上面这种场景,是比较特殊的场景,函数签名一致并且是同步函数。在真正工作中更普遍的场景是:

  1. 函数签名不一致,如process1(String),process2(Int, String)

  2. 函数是异步操作,而且回调的闭包类型也不一样等。

函数签名不一致

要能组合函数类型不一致的问题,可以参考:利用柯里化去除重复代码,利用柯里化 (严格来说叫partial function application) 可以很容易解决。

代码示例如下:

process1(_ param: String) -> String
process2(_ i: Int, _ param: String) -> String
process3(_ i: Int, _ param: String) -> String
process4(_ i: Int, _ param: String) -> String

process1 ++ curry(process2) ++ curry(process3) ++ curry(process4)

不过这儿补充下,有柯里化,就有 反柯里化 。反柯里化就是给函数增加参数,让该函数跟其它函数类型对齐。

反柯里化的一种简单实现如下:

func uncurry(function: @escaping (String) -> String) -> (String, Int) -> String {
    return { s, _ in function(s) }
}

利用该反柯里化方式,新的组合代码可以适度简化为这样:

uncuryy(process1) ++ process2 ++ process3 ++ process4

uncurry完善的实现,可以参考Github上的一些实现,如 swift-overture

异步操作

再来看异步操作的问题。

说到异步处理,如果熟悉一些异步处理框架,如PromiseKit或RxSwift,那么可能知道PromiseKit里的Promise或RxSwift里的Observable这两个对象。

仔细想想,Promise和Observable本身就是很有意思的对象,这些对象可以封装异步操作,当然,也可以表示同步操作,表示纯数据等。这些对象本身也提供了很多操作,操作之后,返回的结果仍然是该对象类型。(在函数式编程里面,这两个对象都可以理解为Monad对象)

理解上面这一点是关键,如果Observable本身可以封装异步操作,那么,一个异步操作就可以表达为一个同步函数,只是返回对象是一个代表同步或异步的对象。这样异步的问题就转变为同步处理的问题了。

下面继续举个简单的例子

假设有如下4个异步操作:

asyncProcess1
asyncProcess2_1
asyncProcess2_2
asyncProcess3

1、2、3这几个是并发,2_1和2_2是串行

用RxSwift写的传统代码大概如下:

asyncProcess1(param: [String]) -> Observable

  {}
 
asyncProcess2_1(param1: Int, 
 param2: [
 String]) -> Observable
 
   {}
  
asyncProcess2_2(param: [
  String]) -> Observable
  
    {}
   
asyncProcess3(param: [
   String]) -> Observable
   
     {}
    

    

    let process2 = Observable.concat(asyncProcess2_1(value, strs), asyncProcess2_2(strs))
    

    let process = Observable.merge([asyncProcess1(strs), process2, asyncProcess3(strs)])
    

    // some code
    

   
  
 

下面我们就尝试重构下该代码。

先定义下通用的concat和merge的操作符:

// 并发两个函数,合并成一个函数
infix operator ||| : RxPrecedence
// 串行两个函数,合并成一个函数
infix operator >>> : RxPrecedence

typealias RxOper

  = (T) -> Observable
 

func ||| 
  
   (lfun: 
   @escaping RxOper
   
    , rfun: 
    @escaping RxOper
    
     ) -> RxOper
     
       {
      
    
      return { value 
      in
      
        Observable.merge([lfun(value), rfun(value)])
      
    }
      
}
      

      
func >>> 
      
       (lfun: 
       @escaping RxOper
       
        , rfun: 
        @escaping RxOper
        
         ) -> RxOper
         
           {
          
    
          return { value 
          in
          
        lfun(value).concat(rfun(value))
          
    }
          
}
          

         
        
       
      
     
    
   
  

然后写相应的业务代码:

// 新的处理代码
let process = asyncProcess1 ||| (curry(asyncProcess2_1)(value) >>> asyncProcess2_2) ||| asyncProcess3
// process(strs)...

新代码的优势一目了然。并且这些例子都是拿的非常简单的示例来讲解的,真正的使用场景上,当操作数量逐渐增加,操作逻辑逐渐复杂时,传统的代码写法的冗余就越能显现。

参考资料

  • Function Composition in Swift

  • RxSwift中文文档

分享给小伙伴们:
本文标签: RxSwift函数式编程

相关文章

发表评论愿您的每句评论,都能给大家的生活添色彩,带来共鸣,带来思索,带来快乐。

CopyRight © 2015-2016 QingPingShan.com , All Rights Reserved.

清屏网 版权所有 豫ICP备15026204号