优雅的函数设计

Posted 2021-08-21 木兮同学

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了优雅的函数设计相关的知识，希望对你有一定的参考价值。

文章目录

1. 拆分超大函数
2. 同一函数内代码块级别尽量一致
3. 封装相同功能代码为函数
4. 封装获取参数值函数
5. 通过接口参数化封装相同逻辑
6. 减少函数代码层级
7. 封装条件表达式函数
8. 尽量避免返回的数组和列表为 null

1. 拆分超大函数

当一个函数超过 80 行后，就属于超大函数，需要进行拆分。

案例一：每一个代码块封装成一个函数

每一个代码块必然有一个注释，用于解释这个代码块的功能。
如果代码块前方有一行注释，就是在提醒你——可以将这段代码替换成一个函数，而且可以在注释的基础上给这个函数命名。如果函数有一个描述恰当的名字，就不需要去看内部代码究竟是如何实现的。
现象描述

	public void liveDaily() {
        // 吃饭
        // 吃饭相关代码几十行

        // 编码
        // 编码相关代码几十行

        // 睡觉
        // 睡觉相关代码几十行
    }

建议方案

	public void liveDaily() {
        // 吃饭
        eat();

        // 编码
        code();

        // 睡觉
        sleep();
    }

    private void sleep() {
    }

    private void code() {
    }

    private void eat() {
    }

案例二：每一个循环体都可以封装为一个函数

现象描述

	public void live() {
        while (isAlive) {

            // 吃饭
            eat();

            // 编码
            code();

            // 睡觉
            sleep();
        }
    }

建议方案

	public void live() {
        while (isAlive) {
            // 每日生活
            liveDaily();
        }
    }

    private void liveDaily() {
        // 吃饭
        eat();

        // 编码
        code();

        // 睡觉
        sleep();
    }

案例三：每一个条件体都可以封装为一个函数

现象描述

	public void goOut() {
        // 判断是否周末
        // 判断是否周末: 是周末则游玩
        if (isWeekday()) {
            // 游玩代码几十行
        }
        // 判断是否周末: 非周末则工作
        else {
            // 工作代码几十行
        }
    }

建议方案

	public void goOut() {
        // 判断是否周末
        // 判断是否周末: 是周末则游玩
        if (isWeekday()) {
            play();
        }
        // 判断是否周末: 非周末则工作
        else {
            work();
        }
    }
    private void play() {
        // 游玩代码几十行
    }
    private void work() {
        // 工作代码几十行
    }

主要收益
- 函数越短小精悍，功能就越单一，往往生命周期较长；
- 一个函数越长，就越不容易理解和维护，维护人员不敢轻易修改；
- 在过长函数中，往往含有难以发现的重复代码。

2. 同一函数内代码块级别尽量一致

现象描述

	public void liveDaily() {
        
        // 吃饭
        eat();
        
        // 编码
        code();
        
        // 睡觉
        // 睡觉相关代码几十行
    }

很明显，睡觉这块代码块，跟 eat（吃饭）和 code（编码）不在同一级别上，显得比较突兀。如果把写代码比作写文章，eat（吃饭）和 code（编码）是段落大意，而睡觉这块代码块属于一个详细段落。而在 liveDaily 这个函数上，只需要写出主要流程（段落大意）即可。
建议方案

	public void liveDaily() {
        // 吃饭
        eat();
        // 编码
        code();
        // 睡觉
        sleep();
    }
    // 睡觉
    private void sleep() {
        // 睡觉相关代码
    }

主要收益
- 函数调用表明用途，函数实现表达逻辑，层次分明便于理解；
- 不用层次的代码块放在一个函数中，容易让人觉得代码头重脚轻。

3. 封装相同功能代码为函数

案例一：封装相同代码为函数

现象描述

	public void disableUser() {
        // 禁用黑名单用户
        List<Long> userIdList = queryBlackUser();
        for (Long userId : userIdList) {
            User userUpdate = new User();
            userUpdate.setId(userId);
            userUpdate.setEnable(Boolean.FALSE);
            userDAO.update(userUpdate);
        }
        // 禁用过期用户
        userIdList = queryExpiredUser();
        for (Long userId : userIdList) {
            User userUpdate = new User();
            userUpdate.setId(userId);
            userUpdate.setEnable(Boolean.FALSE);
            userDAO.update(userUpdate);
        }
    }

建议方案

	public void disableUser() {
        // 禁用黑名单用户
        List<Long> userIdList = queryBlackUser();
        for (Long userId : userIdList) {
            disableUser(userId);
        }
        // 禁用过期用户
        userIdList = queryExpiredUser();
        for (Long userId : userIdList) {
            disableUser(userId);
        }
    }
    private void disableUser(Long userId) {
        User userUpdate = new User();
        userUpdate.setId(userId);
        userUpdate.setEnable(Boolean.FALSE);
        userDAO.update(userUpdate);
    }

案例二：封装相似代码为函数

封装相似代码为函数，差异性通过函数参数控制。
现象描述

	// 通过工单函数
    public void adoptOrder(Long orderId) {
        Order orderUpdate = new Order();
        orderUpdate.setId(orderId);
        orderUpdate.setStatus(OrderStatus.ADOPTED);
        orderUpdate.setAuditTime(new Date());
        orderDAO.update(orderUpdate);
    }
    // 驳回工单函数
    public void rejectOrder(Long orderId) {
        Order orderUpdate = new Order();
        orderUpdate.setId(orderId);
        orderUpdate.setStatus(OrderStatus.REJECTED);
        orderUpdate.setAuditTime(new Date());
        orderDAO.update(orderUpdate);
    }

建议方案

	// 通过工单函数
    public void adoptOrder(Long orderId) {
        auditOrder(orderId, OrderStatus.ADOPTED);
    }
    // 驳回工单函数
    public void rejectOrder(Long orderId) {
        auditOrder(orderId, OrderStatus.REJECTED);
    }
    // 审核工单函数
    private void auditOrder(Long orderId, OrderStatus
            orderStatus) {
        Order orderUpdate = new Order();
        orderUpdate.setId(orderId);
        orderUpdate.setStatus(orderStatus);
        orderUpdate.setAuditTime(new Date());
        orderDAO.update(orderUpdate);
    }

主要收益
- 封装公共函数，减少代码行数，提高代码质量；
- 封装公共函数，使业务代码更精炼，可读性可维护性更强。

4. 封装获取参数值函数

现象描述

	// 是否通过函数
	public boolean isPassed(Long userId) {
        // 获取通过阈值
        double thisPassThreshold = PASS_THRESHOLD;
        if (Objects.nonNull(passThreshold)) {
            thisPassThreshold = passThreshold;
        }
        // 获取通过率
        double passRate = getPassRate(userId);
        // 判读是否通过
        return passRate >= thisPassThreshold;
    }

建议方案

	// 是否通过函数
    public boolean isPassed(Long userId) {
        // 获取通过阈值
        double thisPassThreshold = getPassThreshold();
        // 获取通过率
        double passRate = getPassRate(userId);
        // 判读是否通过
        return passRate >= thisPassThreshold;
    }
    // 获取通过阈值函数
    private double getPassThreshold() {
        if (Objects.nonNull(passThreshold)) {
            return passThreshold;
        }
        return PASS_THRESHOLD;
    }

主要收益
- 把获取参数值从业务函数中独立，使业务逻辑更清晰；
- 封装的获取参数值为独立函数，可以在代码中重复使用。

5. 通过接口参数化封装相同逻辑

现象描述

	// 发送审核员结算数据函数
    public void sendAuditorSettleData() {
        List<WorkerSettleData> settleDataList = auditTaskDAO.statAuditorSettleData();
        for (WorkerSettleData settleData : settleDataList) {
            WorkerPushData pushData = new WorkerPushData();
            pushData.setId(settleData.getWorkerId());
            pushData.setType(WorkerPushDataType.AUDITOR);
            pushData.setData(settleData);
            pushService.push(pushData);
        }
    }

    // 发送验收员结算数据函数
    public void sendCheckerSettleData() {
        List<WorkerSettleData> settleDataList = auditTaskDAO.statCheckerSettleData();
        for (WorkerSettleData settleData : settleDataList) {
            WorkerPushData pushData = new WorkerPushData();
            pushData.setId(settleData.getWorkerId());
            pushData.setType(WorkerPushDataType.CHECKER);
            pushData.setData(settleData);
            pushService.push(pushData);
        }
    }

建议方案

	// 发送审核员结算数据函数
    public void sendAuditorSettleData() {
        sendWorkerSettleData(WorkerPushDataType.AUDITOR, () -> auditTaskDAO.statAuditorSettleData());
    }

    // 发送验收员结算数据函数
    public void sendCheckerSettleData() {
        sendWorkerSettleData(WorkerPushDataType.CHECKER, () -> auditTaskDAO.statCheckerSettleData());
    }

    // 发送作业员结算数据函数
    public void sendWorkerSettleData(WorkerPushDataType dataType, WorkerSettleDataProvider dataProvider) {
        List<WorkerSettleData> settleDataList = dataProvider.statWorkerSettleData();
        for (WorkerSettleData settleData : settleDataList) {
            WorkerPushData pushData = new WorkerPushData();
            pushData.setId(settleData.getWorkerId());
            pushData.setType(dataType);
            pushData.setData(settleData);
            pushService.push(pushData);
        }
    }

    // 作业员结算数据提供者接口
    private interface WorkerSettleDataProvider {
        // 统计作业员结算数据
        List<WorkerSettleData> statWorkerSettleData();
    }

主要收益
- 把核心逻辑从各个业务函数中抽析，使业务代码更清晰
  更易维护；
- 避免重复性代码多次编写，精简重复函数越多收益越
  大。

6. 减少函数代码层级

如果要使函数优美，建议函数代码层级在 1-4 之间，过多的缩进会让函数难以阅读。

案例一：利用 return 提前返回函数

现象描述

	// 获取用户余额函数
    public Double getUserBalance(Long userId) {
        User user = getUser(userId);
        if (Objects.nonNull(user)) {
            UserAccount account = user.getAccount();
            if (Objects.nonNull(account)) {
                return account.getBalance();
            }
        }
        return null;
    }

方案建议

	// 获取用户余额函数
    public Double getUserBalance(Long userId) {
        // 获取用户信息
        User user = getUser(userId);
        if (Objects.isNull(user)) {
            return null;
        }
        // 获取用户账户
        UserAccount account = user.getAccount();
        if (Objects.isNull(account)) {
            return null;
        }
        // 返回账户余额
        return account.getBalance();
    }

案例二：利用 continue 提前结束循环

现象描述

	// 获取合计余额函数
    public double getTotalBalance(List<User> userList) {
        // 初始合计余额
        double totalBalance = 0.0D;
        // 依次累加余额
        for (User user : userList) {
            // 获取用户账户
            UserAccount account = user.getAccount();
            if (Objects.nonNull(account)) {
                // 累加用户余额
                Double balance = account.getBalance();
                if (Objects.nonNull(balance)) {
                    totalBalance += balance;
                }
            }
        }
        // 返回合计余额
        return totalBalance;
    }

方案建议

	// 获取合计余额函数
    public double getTotalBalance(List<User> userList) {
        // 初始合计余额
        double totalBalance = 0.0D;
        // 依次累加余额
        for (User user : userList) {
            // 获取用户账户
            UserAccount account = user.getAccount();
            if (Objects.isNull(account)) {
                continue;
            }
            // 累加用户余额
            Double balance = account.getBalance();
            if (Objects.nonNull(balance)) {
                totalBalance += balance;
            }
        }
        // 返回合计余额
        return totalBalance;
    }

主要收益
- 代码层级减少，代码缩进减少；
- 模块划分清晰，方便阅读维护。

7. 封装条件表达式函数

案例一：把简单条件表达式封装为函数

现象描述

	// 获取门票价格函数
    public double getTicketPrice(Date currDate) {
        if (Objects.nonNull(currDate) && currDate.after(DISCOUNT_BEGIN_DATE)
                && currDate.before(DISCOUNT_END_DATE)) {
            return TICKET_PRICE * DISCOUNT_RATE;
        }
        return TICKET_PRICE;
    }

方案建议

	// 获取门票价格函数
    public double getTicketPrice(Date currDate) {
        if (isDiscountDate(currDate)) {
            return TICKET_PRICE * DISCOUNT_RATE;
        }
        return TICKET_PRICE;
    }

    // 是否折扣日期函数
    private static boolean isDiscountDate(Date currDate) {
        return Objects.nonNull(currDate) &&
                currDate.after(DISCOUNT_BEGIN_DATE)
                && currDate.before(DISCOUNT_END_DATE);
    }

案例二：把复杂条件表达式封装为函数

现象描述

	// 获取土豪用户列表
    public List<User> getRichUserList(List<User> userList) {
        // 初始土豪用户列表
        List<User> richUserList = new ArrayList<>();
        // 依次查找土豪用户
        for (User user : userList) {
            // 获取用户账户
            UserAccount account = user.getAccount();
            if (Objects.nonNull(account)) {
                // 判断用户余额
                Double balance = account.getBalance();
                if (Objects.nonNull(balance) &&
                        balance.compareTo(RICH_THRESHOLD) >= 0) {
                    // 添加土豪用户
                    richUserList.add(user);
                }
            }
        }
        // 返回土豪用户列表
        return richUserList;
    }

方案建议

	// 获取土豪用户列表
    public List<User> getRichUserList(List<User> userList) {
        // 初始土豪用户列表
        List<User> richUserList = new ArrayList<>();
        // 依次查找土豪用户
        以上是关于优雅的函数设计的主要内容，如果未能解决你的问题，请参考以下文章 
 优雅的函数设计
 重构.改善既有代码的设计11处理概括关系更优雅的继承
 如何有条件地将 C 代码片段编译到我的 Perl 模块？
 Python优雅地可视化数据
 重构.改善既有代码的设计8重新组织数据（更优雅的面向对象）
 html 优雅的博客时事通讯片段