重构第九章:简化条件表达式

第九章详细阐述了一系列简化条件表达式的重构手法,旨在提高代码的可读性和可维护性。以下是第九章中列举的一些简化条件表达式的重构手法,通过通俗易懂的语言和具体示例来进一步解释:

分解条件表达式(Decompose Conditional): 当一个复杂的条件表达式难以理解时,将其分解为若干个小条件,使每个条件表达式的意图更加明确。
// Before
if (isSummer() && (temperature > 30)) {
    // do something
}

// After
if (isSummer()) {
    if (temperature > 30) {
        // do something
    }
}

合并条件表达式(Consolidate Conditional Expression): 多个条件表达式执行相同的操作时,将这些条件表达式合并为一个条件表达式,使得代码更加简洁。

// Before
if (isWeekend()) {
    doSomething();
}

if (isWeekday()) {
    doSomething();
}

// After
if (isWeekend() || isWeekday()) {
    doSomething();
}

以卫语句取代嵌套条件表达式(Replace Nested Conditional with Guard Clauses): 当使用嵌套的条件表达式难以阅读时,使用卫语句替代,提高代码的清晰度。

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

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

以条件表达式取代卫语句(Replace Guard Clauses with Conditional Expression): 过多的卫语句导致代码重复时,将卫语句合并为一个条件表达式,使得代码更加简洁。

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

// After
double getPayAmount() {
    return (isDead) ? deadAmount()
        : (isSeparated) ? separatedAmount()
        : (isRetired) ? retiredAmount()
        : normalPayAmount();
}

引入特例(Introduce Special Case): 使用大量的条件判断来处理特殊情况时,引入特例对象,将特殊情况的处理逻辑封装在特例对象中,使得代码更简单。

// Before
double getPayAmount(Employee employee) {
    if (employee.isRetired()) {
        return employee.getRetiredAmount();
    } else {
        return employee.getNormalPayAmount();
    }
}

// After
double getPayAmount(Employee employee) {
    return employee.getPayAmount();
}

移除控制标记(Remove Control Flag): 使用控制标记来控制程序流程时,将控制标记替换为更加清晰的控制结构,使得代码逻辑更容易理解。

// Before
void checkSecurity(String[] people) {
    boolean found = false;
    for (String person : people) {
        if (!found) {
            if (person.equals("Don")) {
                sendAlert();
                found = true;
            }
            if (person.equals("John")) {
                sendAlert();
                found = true;
            }
        }
    }
}

// After
void checkSecurity(String[] people) {
    for (String person : people) {
        if (person.equals("Don") || person.equals("John")) {
            sendAlert();
            break;
        }
    }
}

以策略取代条件表达式(Replace Conditional with Strategy): 多个条件表达式根据相同的条件选择不同的行为时,将条件表达式替换为策略模式,每个策略对象实现不同的行为。

// Before
double calculateDiscount(Order order) {
    if (order.getTotalAmount() > 1000) {
        return order.getTotalAmount() * 0.1;
    } else {
        return order.getTotalAmount() * 0.05;
    }
}

// After
interface DiscountStrategy {
    double applyDiscount(Order order);
}

class TenPercentDiscount implements DiscountStrategy {
    @Override
    public double applyDiscount(Order order) {
        return order.getTotalAmount() * 0.1;
    }
}

class FivePercentDiscount implements DiscountStrategy {
    @Override
    public double applyDiscount(Order order) {
        return order.getTotalAmount() * 0.05;
    }
}

合并重复的条件片段(Consolidate Duplicate Conditional Fragments): 多个条件片段执行相同的操作时,将重复的条件片段合并为一个条件片段,避免重复代码。

// Before
void applyDiscount(Order order) {
    if (order.getTotalAmount() > 1000) {
        order.setDiscount(order.getTotalAmount() * 0.1);
    } else {
        order.setDiscount(order.getTotalAmount() * 0.05);
    }
    sendEmail(order);
}

// After
void applyDiscount(Order order) {
    double discount = (order.getTotalAmount() > 1000) ? 0.1 : 0.05;
    order.setDiscount(order.getTotalAmount() * discount);
    sendEmail(order);
}

移除与参数无关的代码(Remove Redundant Code): 条件表达式中存在与参数无关的冗余代码时,移除与参数无关的冗余代码,使得代码更加简洁。

// Before
boolean canApplyDiscount(Order order) {
    if (order.isVerified() && order.getTotalAmount() > 100) {
        return true;
    } else {
        return false;
    }
}

// After
boolean canApplyDiscount(Order order) {
    return order.isVerified() && order.getTotalAmount() > 100;
}

以查询取代临时变量(Replace Temp with Query): 使用临时变量保存计算结果,增加了代码的复杂性时,将临时变量替换为查询方法,使得代码更加清晰。

// Before
double calculateTotalPrice(Order order) {
    double basePrice = order.getBasePrice();
    return basePrice * 1.2;
}

// After
double calculateTotalPrice(Order order) {
    return order.getBasePrice() * 1.2;
}

这些简化条件表达式的重构手法有助于提高代码的可读性、可维护性,并使得条件逻辑更加清晰。在应用这些手法时,要根据具体的情况选择合适的手法,确保代码的质量和可维护性。就像是用更简单的语言讲述故事,让代码更容易理解和维护。

你可能感兴趣的:(团队合作优雅之道,重构,chrome,前端)