10 简化条件逻辑

分解条件表达式

对条件判断和每个条件分支分别运用提炼函数手法。

将大块头代码分解为多个独立的函数，并根据每个小块代码的用途，为分解得到的新函数命名。

重构前：

if (!aData.isBefore(plan.summerStart) && !aData.isAfter(plan.summerEnd)) {
    // 计算夏季总价
    charge = quantity * plan.summerRate;
} else {
    // 计算平时总价
    charge = quantity * plan.regularRate + plan.regularServiceCharge;
}

重构后：

if (summer()) {
    charge = summerCharge();
} else {
    charge = regularCharge();
}

charge = summer() ? summerCharge() : regularCharge();

合并条件表达式

当检查条件各不相同，但最终行为却一致时，应该使用 “逻辑或” 和 “逻辑与” 将它们合并为一个条件表达式。

做法：

• 使用适当的逻辑运算符，将条件表达式合并为一个（顺序执行的条件表达式使用逻辑或；嵌套的 if 语句使用逻辑与）
• 对合并后的条件表达式实施提炼函数

使用逻辑或合并条件表达式

重构前：

public double disabilityAmount(anEmployee) {
    if (anEmployee.seniority < 2) {
        return 0;
    }
    if (anEmployee.monthsDisabled > 12) {
        return 0;
    }
    if (anEmployee.isPartTime) {
        return 0
    }
    // 计算伤残金
}

重构后：

public double disabilityAmount(anEmployee) {
    if (isNotEligableForDisability()) {
        return 0;
    }
    // 计算伤残金
}

// 没有资格获得伤残金的
private boolean isNotEligableForDisability() {
    return anEmployee.seniority < 2 
    || anEmployee.monthsDisabled > 12
    || anEmployee.isPartTime;
}

使用逻辑与合并条件表达式

重构前：

if (anEmployee.onVacation) {
    if (anEmployee.seniority > 10) {
        return 1;
    } 
}
return 0.5;

重构后：

if (anEmployee.onVacatopm && anEmployee.seniority > 10) {
    return 1;
}
return 0.5;

以卫语句取代嵌套条件表达式

条件表达式通常有两种风格：

• 如果两条分支都是正常行为，则应该使用 if...else... 条件表达式
• 如果某个条件极其罕见，旧应该单独检查该条件，并且在条件为真时立刻从函数中返回（卫语句）

范例1

重构前：

public double getPayAmount() {
    double result;
    if (isDead) {
        result = deadAmount();
    } else {
        if (isSeparated) {
            result = separatedAmount();
        } else {
            if (isRetired) {
                result = retiredAmount();
            } else {
                result = normalPayAmount();
            }
        }
    }
    return result;
}

重构后：

public double getPayAmount() {
    if (isDead) {
        return deadAmount();
    }
    if (isSeparated) {
        return separatedAmount();
    }
    if (isRetired) {
        return retiredAmount();
    }
    return normalPayAmount();
}

范例2 将条件反转

重构前：

public double adjustedCapital(anInstrument) {
    double result = 0;
    if (anInstrument.capitail > 0) {
        if (anInstrument.interestRate > 0 && anInstrument.duration > 0) {
            result = (anInstrument.income / anInstrument.duration) * anInstrument.adjustmentFactor;
        }
    }
    return result;
}

重构后：

public double adjustedCapital(anInstrument) {
    if (anInstrument.capitail <= 0) {
        return 0;
    }
    if (anInstrument.interestRate <= 0 || anInstrument.duration <= 0) {
        return 0;
    }
    return (anInstrument.income / anInstrument.duration) * anInstrument.adjustmentFactor;
}

public double adjustedCapital(anInstrument) {
    if (anInstrument.capitail <=> 0 
    || anInstrument.interestRate <>= 0 
    || anInstrument.duration <= 0) {
        return 0;
    }
    return (anInstrument.income / anInstrument.duration) * anInstrument.adjustmentFactor;
}

以多态取代条件表达式

以多态取代条件表达式的场景：

• 有多处地方出现 swtich 基于不同类型做出不同的处理
• 有一个基础的逻辑（超类），在其上又有一些变体（子类）

重构前：

// 不同鸟类的速度
switch (bird.type) {
    case "EuropeanSwallow":
        return 35;
    case "AricanSwallow":
        return 40 - 2 * bird.numberOfCoconuts;
    case "NorwegianBlueParrot":
        return bird.isNailed ? 0 : (10 + bird.voltage / 10);
    default:
        return null;
}

重构之后：

BirdFactory.createBird(birdType).getSpeed();

class BirdFactory() {
    public static createBird(String birdType) {
        switch (birdType) {
            case "EuropeanSwallow":
                return new EuropeanSwallow();
            case "AricanSwallow":
                return new AricanSwallow();
            case "NorwegianBlueParrot":
                return new NorwegianBlueParrot();
            default:
                return new Bird();
        }
    }
}

class Bird {
    public double getSpeed() {
        return null;
    }
}

class EuropeanSwallow extends Bird {
    @Override
    public double getSpeed() {
        return 35;
    }
}

class AricanSwallow extends Bird {
    @Override
    public double getSpeed() {
        return 40 - 2 * bird.numberOfCoconuts;
    }
}

class NorwegianBlueParrot extends Bird {
    @Override
    public double getSpeed() {
        return bird.isNailed ? 0 : (10 + bird.voltage / 10);
    }
}

引入特例

当一个数据结构的使用者都在检查某个特殊的值，就可以使用特例模式。

特例模式（Special Case）：创建一个特例元素，用以表达对这种特例的共用行为的处理。
通常需要特例处理的值就是 null 值，这个也是这个模式常被叫做 “Null 对象” 模式的原因。

重构前：

// 第一处地方
String customerName;
if (customer == null) {
    customerName = "occupant";
} else {
    customerName = customer.getName();
}

// 第二处地方
double plan;
if (customer == null) {
    plan = registry.getBillingPlans().getBasic();
} else {
    customer.getBillingPlan();
}

// ...

重构后：

class Customer {
    // ...
}

// 引入特例
class UnknownCustomer extends Customer {
    @Override
    public String getName() {
        return "occupant";
    }

    @Override
    public String getPlan() {
        return registry.getBillingPlans().getBasic();;
    }
}

// 第一处地方
String customerName = customer.getName();

// 第二处地方
double plan = customer.getBillingPlan();

// ...

引入断言

使用断言来对明确地表达某种假设。

断言用于预防程序员的错误，对于输入外部数据都应该执行检查而不能用断言实现。

// 折扣应该不小于 0
assert this.discountRate >= 0;
if (this.discountRate > 0) {
    base = base - (this.discountRate * base);
}

参阅

• 《重构：改善既有代码的设计（第2版）》

原文地址：http://www.cnblogs.com/liaozibo/p/simplifying-conditional-logic.html