(翻译) 重构成模式:用策略模式来替代臃肿的条件逻辑




24bbba066362339b1888592f72f3b41.jpg


原创作者:Yerassyl
原文链接:https://medium.com/@Yerazhas/refactoring-to-patterns-replace-conditional-logic-with-strategy-9970e057093a


代码中最常见的复杂部分之一是复杂的条件逻辑.
                                                                 -- Martin Fowler



今天我们将会探索怎么去用策略模式重构条件逻辑代码。目前已经有很多关于重构复杂条件逻辑代码的方式,比如分解条件,组合方法,用多态性代替条件等等。


如果你需要在运行时将一些算法与另一个算法交换,那么你应该选择策略模式(strategy)类。当创建策略模式类的时候,有2种方式给他们传数据:

  • 传主类
  • 像参数一样传递数据


    我们这里的 Loan 类是用来计算各种类型贷款的资本的,例如定期贷款,周转金贷款,信用贷款。

class Loan {
    var expiryDate: String?
    var maturityDate: String?
    
    func capital() -> Double {
        if expiryDate != nil && maturityDate != nil {
            return 10.0 * duration() * riskFactor()
        }
        if expiryDate != nil && maturityDate == nil {
            if getUnusedPercentage() > 1.0 {
                return 150.0 * getUnusedPercentage()
            } else {
                return 200.0 * getUnusedPercentage()
            }
        }
        
        return 0.0
    }
    
    func duration() -> Double {
        return 0.0
    }
    
    func riskFactor() -> Double {
        return 0.0
    }
    
    func getUnusedPercentage() -> Double {
        return 5.0
    }
}



这个类有许多条件逻辑来确定贷款的类型。例如,expiryDate 为空,而且 maturityDate 不空的时候,就是一个定期贷款。

然后我们创建抽象的 CapitalStrategy 类(这里是protocol),还有TermLoanCapitalStrategyRevolverCapitalStrategy子类,他们都实现自己的capital() -> Double 方法。

protocol CapitalStrategy {
    func capital(loan: Loan) -> Double
    func riskFactor() -> Double
}

extension CapitalStrategy {
    func riskFactor() -> Double {
        return 0.0
    }
}

class RevolverCapitalStrategy: CapitalStrategy {
    func capital(loan: Loan) -> Double {
        return 250 * riskFactor()
    }
}

class TermLoanCapitalStrategy: CapitalStrategy {
    func capital(loan: Loan) -> Double {
        if loan.expiryDate != nil && loan.maturityDate != nil {
            return 10.0 * loan.duration() * riskFactor()
        }
        if loan.expiryDate != nil && loan.maturityDate == nil {
            if loan.getUnusedPercentage() > 1.0 {
                return 150.0 * loan.getUnusedPercentage()
            } else {
                return 200.0 * loan.getUnusedPercentage()
            }
        }
        
        return 0.0
    }
}


最后,我们用静态方法来代替构造函数。

final class Loan {
    var expiryDate: String?
    var maturityDate: String?
    private var capitalStrategy: CapitalStrategy
    
    private init(capitalStrategy: CapitalStrategy) {
        self.capitalStrategy = capitalStrategy
    }
    
    static func termLoan() -> Loan {
        return self.init(capitalStrategy: TermLoanCapitalStrategy())
    }
    
    static func revolver() -> Loan {
        return self.init(capitalStrategy: RevolverCapitalStrategy())
    }
    
    func capital() -> Double {
        return capitalStrategy.capital(loan: self)
    }
    
    func duration() -> Double {
        return 0.0
    }
    
    func getUnusedPercentage() -> Double {
        return 5.0
    }
}



就这样,我们单独的方法有了明确的名称和具体的策略对象(CapitalStrategy),这个对象实现了 capital() -> Double 方法。

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容