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），还有TermLoanCapitalStrategy，RevolverCapitalStrategy子类，他们都实现自己的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 方法。