优化if-else的11种方案

简介: 优雅编码不仅提升程序效率,也增进代码可读性与维护性。通过早返回减少嵌套逻辑、运用三元运算符简化条件判断、采用`switch-case`优化多分支结构、实施策略模式灵活应对不同情境、利用查找表快速定位处理方式、封装函数明确职责划分、应用命令模式解耦操作与调用、引入状态模式管理复杂状态变化、重构条件表达式以增强清晰度、运用断言确保前提条件、及合理异常处理等十大技巧,使代码更加精炼与优雅。

优雅永不过时!

image-20240805201630837

1. 使用早返回(Early Return):尽可能早地返回,避免嵌套的if-else。

优化前:

public class NoEarlyReturnExample {
   
   
    public boolean hasPositiveNumber(int[] numbers) {
   
   
        boolean foundPositive = false;
        for (int number : numbers) {
   
   
            if (number > 0) {
   
   
                foundPositive = true;
                // 没有早返回,而是继续循环
            }
        }
        return foundPositive; // 循环结束后返回结果
    }
}

优化后:

public class EarlyReturnExample {
   
   
    public boolean hasPositiveNumber(int[] numbers) {
   
   
        for (int number : numbers) {
   
   
            if (number > 0) {
   
   
                return true; // 找到正数立即返回
            }
        }
        return false; // 没有找到正数
    }
}

减少了多次循环

2. 使用三元运算符:在条件简单的情况下,可以使用三元运算符来简化代码。

优化前:

public class NoTernaryOperatorExample {
   
   
    public String getGender(int number) {
   
   
        if (number > 0) {
   
   
            return "girl";
        } else if (number < 0) {
   
   
            return "boy";
        } else {
   
   
            return "other";
        }
    }
}

优化后:

public class TernaryOperatorExample {
   
   
    public String getGender(int number) {
   
   
        return (number > 0) ? "girl" : (number < 0) ? "boy" : "other";
    }
}

3. 使用switch-case语句:如果你的条件是基于不同的情况或值,更好的选择是switch-case。

优化前:

public class NoSwitchCaseExample {
   
   
    public void performAction(String action) {
   
   
        if ("start".equals(action)) {
   
   
            System.out.println("Starting...");
        } else if ("stop".equals(action)) {
   
   
            System.out.println("Stopping...");
        } else {
   
   
            System.out.println("Unknown action");
        }
    }
}

优化后:

public class SwitchCaseExample {
   
   
    public void performAction(String action) {
   
   
        switch (action) {
   
   
            case "start":
                System.out.println("Starting...");
                break;
            case "stop":
                System.out.println("Stopping...");
                break;
            default:
                System.out.println("Unknown action");
        }
    }
}

4. 使用策略模式:将每个条件分支封装成一个策略对象,然后根据条件选择使用哪个策略。

优化前:

public class NoStrategyExample {
   
   
    public void context() {
   
   
        // 没有使用策略模式,而是直接执行代码
        System.out.println("Direct execution");
        // do something...
    }
}

优化后:

public class StrategyExample {
   
   
    interface Strategy {
   
   
        void execute();
    }

    public class ConcreteStrategyA implements Strategy {
   
   
        public void execute() {
   
   
            System.out.println("Strategy A executed");
        }
    }

    public void context(Strategy strategy) {
   
   
        strategy.execute();
    }
}

5. 使用查找表:对于固定数量的条件分支,可以使用查找表(例如字典或哈希表)来映射条件和对应的行为。

优化前:

public class NoLookupTableExample {
   
   
    public void performAction(String action) {
   
   
        // 没有使用查找表,而是使用if-else
        if ("start".equals(action)) {
   
   
            System.out.println("Starting...");
        } else if ("stop".equals(action)) {
   
   
            System.out.println("Stopping...");
        } else {
   
   
            System.out.println("No action found");
        }
    }
}

优化后:

public class LookupTableExample {
   
   
    public void performAction(Map<String, Runnable> actions, String key) {
   
   
        actions.getOrDefault(key, () -> System.out.println("No action found")).run();
    }
}

6. 使用函数或方法:将每个条件分支的逻辑封装到不同的函数或方法中,然后在if-else中调用这些函数。

优化前:

public class NoFunctionExample {
   
   
    public void handleUserType(String userType) {
   
   
        // 没有使用函数封装,而是直接在if-else中编写逻辑
        if ("admin".equals(userType)) {
   
   
            System.out.println("Admin logic here");
        } else if ("user".equals(userType)) {
   
   
            System.out.println("User logic here");
        } else {
   
   
            System.out.println("Guest logic here");
        }
    }
}

优化后:

public class FunctionExample {
   
   
    public void handleUserType(String userType) {
   
   
        if ("admin".equals(userType)) {
   
   
            handleAdmin();
        } else if ("user".equals(userType)) {
   
   
            handleUser();
        } else {
   
   
            handleGuest();
        }
    }

    private void handleAdmin() {
   
   
        System.out.println("Handling admin");
    }

    private void handleUser() {
   
   
        System.out.println("Handling user");
    }

    private void handleGuest() {
   
   
        System.out.println("Handling guest");
    }
}

这个是大家比较常用的,通过不同的功能拆分成不同的函数。

7. 使用命令模式:将每个条件分支封装成一个命令对象,然后根据条件执行相应的命令。

优化前:

public class NoCommandExample {
   
   
    public void performAction(String action) {
   
   
        // 直接执行动作,没有使用命令模式
        if ("start".equals(action)) {
   
   
            System.out.println("Starting...");
        } else if ("stop".equals(action)) {
   
   
            System.out.println("Stopping...");
        }
    }
}

优化后:

public class CommandExample {
   
   
    interface Command {
   
   
        void execute();
    }

    public class StartCommand implements Command {
   
   
        public void execute() {
   
   
            System.out.println("Starting...");
        }
    }

    public class StopCommand implements Command {
   
   
        public void execute() {
   
   
            System.out.println("Stopping...");
        }
    }

    public void executeCommand(Command command) {
   
   
        command.execute();
    }
}

8. 使用状态模式:如果逻辑分支与状态有关,可以使用状态模式来管理状态转换。

优化前:

public class NoStateExample {
   
   
    public void handleAction(String state) {
   
   
        // 没有使用状态模式,直接在代码中处理逻辑
        if ("start".equals(state)) {
   
   
            System.out.println("Handling start");
        } else if ("stop".equals(state)) {
   
   
            System.out.println("Handling stop");
        }
    }
}

优化后:

public class StateExample {
   
   
    interface State {
   
   
        void handle();
    }

    public class StartState implements State {
   
   
        public void handle() {
   
   
            System.out.println("Handling start state");
        }
    }

    public class StopState implements State {
   
   
        public void handle() {
   
   
            System.out.println("Handling stop state");
        }
    }

    public class Context {
   
   
        private State state;

        public void setState(State state) {
   
   
            this.state = state;
        }

        public void request() {
   
   
            state.handle();
        }
    }
}

状态转换类似于我们在做一个简单的工单流转,每一步都是确定且可复用的场景。

9. 重构条件表达式:检查是否可以将复杂的条件表达式分解为更简单的部分。

优化前:

public class UnrefactoredConditionExample {
   
   
    public boolean isWeekend(int day) {
   
   
        // 没有重构的条件表达式,切套多、不好阅读
        if (day == 6 || (day == 7 && !isHoliday(day))) {
   
   
            return true;
        }
        return false;
    }

    private boolean isHoliday(int day) {
   
   
        // 法定的假日检查逻辑(法定节假日每年都在变)
        return false;
    }
}

优化后:

public class RefactoredConditionExample {
   
   
    public boolean isWeekend(int day) {
   
   
        return day == 6 || day == 7;
    }
}

简洁了很多

10. 使用断言:在某些情况下,使用断言来确保代码的预设条件被满足,避免复杂的条件判断。

优化前:

public class NoAssertExample {
   
   
    public void process(int value) {
   
   
        if (value <= 0) {
   
   
            throw new IllegalArgumentException("Value must be positive");
        }
        // 处理逻辑
        System.out.println("Processing value: " + value);
    }
}

优化后:

public class AssertExample {
   
   
    public void process(int value) {
   
   
        assert value > 0 : "Value must be positive";
        // 处理逻辑
        System.out.println("Processing value: " + value);
    }
}

多数编程中,断言被用在自动化测试用例。不过预设条件判断用起来也非常丝滑。

11. 使用异常处理:在某些情况下,使用异常处理来简化错误条件的处理。

优化前:

public class NoExceptionHandlingExample {
   
   
    public int divide(int dividend, int divisor) {
   
   
        if (divisor == 0) {
   
   
            // 没有使用异常处理,而是直接返回错误代码
            System.out.println("Cannot divide by zero");
            return -1;
        }
        return dividend / divisor;
    }
}

优化后:

public class ExceptionHandlingExample {
   
   
    public int divide(int dividend, int divisor) {
   
   
        try {
   
   
            return dividend / divisor;
        } catch (ArithmeticException e) {
   
   
            System.out.println("Cannot divide by zero");
            return -1;
        }
    }
}

当遇到异常,尽可能在合适的地方捕获并处理,不要直接把所有异常都抛到最外层。

目录
相关文章
|
2月前
|
编解码 前端开发 UED
多屏幕适配方案
【10月更文挑战第7天】
57 1
|
7月前
|
存储 监控 Cloud Native
如何通过持续测试和调整来提高OLAP系统的性能和可扩展性?
【5月更文挑战第14天】如何通过持续测试和调整来提高OLAP系统的性能和可扩展性?
71 2
优化if-else代码的几种方案
优化if-else代码的几种方案
|
数据采集 算法 编译器
倚天710规模化应用 - 性能优化 -自动反馈优化分析与实践
编译器优化分成静态优化与动态优化,静态优化指传统编译器gcc/llvm时,增加的优化等级,如O1,O2,O3,Ofast,此时,编译器会依据编译优化等级增加一些优化算法,如函数inline、循环展开以及分支静态预测等等。一般情况下,优化等级越高,编译器做的优化越多,性能会更会好。在阿里生产环境中,单纯依赖于静态优化,并不能达到程序运行流畅目的,通过分析CPU硬件取指令、执行指令,往往会出现一些分支预测失败导致iCacheMiss率高的场景,限制了程序的性能进一步提升。基于此,业务引入了动态反馈优化工具,依据生产环境的实际运行数据,反哺指导编译器对程序代码进一步调整编译优化策略,提高分支预准确率
|
存储 Oracle JavaScript
300万数据导入导出优化方案,从80s优化到8s(实测)
300万数据导入导出优化方案,从80s优化到8s(实测)
300万数据导入导出优化方案,从80s优化到8s(实测)
|
存储 缓存 NoSQL
性能优化方案及思考
周末闲暇在家,朋友让我帮忙优化一个接口,这个接口之前每次加载都需要40s左右,经过优化将性能提了10倍左右;又加了缓存直接接口响应目前为300ms左右,于是将自己的优化思路整理总结一下
|
SQL 并行计算 Oracle
【笔记】最佳实践—混合负载HTAP的实践和优化
背景信息 本文主要提供数据库上云后OLTP+OLAP一体化架构的最佳实践,既HTAP。主要面对的业务应用范围: 混合型HTAP数据库需求:如ORACLE数据库改造上云,云上数据库方案选型; OLTP系统查询慢,存在分析型场景和瓶颈的客户; 读写分离需求。
267 0
【笔记】最佳实践—混合负载HTAP的实践和优化
|
前端开发 JavaScript NoSQL
6款 Retool 最佳替代方案
本篇文章的目的通过低代码平台使用者的视角引出细节,了解他们为什么使用低代码平台以及会选择哪个低代码平台来加速内部系统的开发。
841 0
6款 Retool 最佳替代方案
代码中大量的if/else,你有什么优化方案?
代码中大量的if/else,你有什么优化方案?
338 0
代码中大量的if/else,你有什么优化方案?
|
SQL 并行计算 Oracle
最佳实践—混合负载HTAP的实践和优化
背景信息 本文主要提供数据库上云后OLTP+OLAP一体化架构的最佳实践,既HTAP。主要面对的业务应用范围: 混合型HTAP数据库需求:如ORACLE数据库改造上云,云上数据库方案选型; OLTP系统查询慢,存在分析型场景和瓶颈的客户; 读写分离需求。
667 0
最佳实践—混合负载HTAP的实践和优化