条件语句重构指引

古城微笑少年丶 2022-10-16 08:43 82阅读 0赞

### 目录 ###

*   *  1 if...else 过多
     *   *  1.1 问题表现
         *  1.2 如何解决
     *  2 if...else 嵌套过深
     *   *  2.1 问题表现
         *  2.2 如何解决
         *   *  2.2.1 抽取方法
             *  2.2.2 卫语句
     *  3 if...else 表达式过于复杂
     *   *  3.1 问题表现
         *  3.2 如何解决
     *  4 switch case分支过多

## 1 if…else 过多 ##

### 1.1 问题表现 ###

`if...else` 过多的代码可以抽象为下面这段代码。其中只列出 5 个逻辑分支，但实际工作中，能见到一个方法包含 10 个、20 个甚至更多的逻辑分支的情况。

另外，`if...else` 过多通常会伴随着另两个问题：

*  逻辑表达式复杂
 *  `if...else` 嵌套过深。

对于后两个问题，本文将在下面两节介绍。本节先来讨论 `if...else` 过多的情况。

if (condition1) { 
    ...
    } else if (condition2) { 
    ...
    } else if (condition3) { 
    ...
    } else if (condition4) { 
    ...
    } else { 
    ...
    }

通常，`if...else` 过多的方法，通常可读性和可扩展性都不好。从软件设计角度讲，代码中存在过多的 `if...else` 往往意味着这段代码违反了单一职责原则和开闭原则。因为在实际的项目中，需求往往是不断变化的，新需求也层出不穷。所以，软件系统的扩展性是非常重要的。而解决`if...else` 过多问题的最大意义，往往就在于提高代码的可扩展性。

### 1.2 如何解决 ###

对于逻辑表达模式固定的 `if...else` 代码，建议采用表驱动方式解决，就是通过某种映射关系，将逻辑表达式用表格的方式表示；再使用表格查找的方式，找到某个输入所对应的处理函数，使用这个处理函数进行运算。

**适用场景**  
逻辑表达模式固定的 `if...else`

**实现与示例**

if (param.equals(value1)) { 
        doAction1(someParams);
    } else if (param.equals(value2)) { 
        doAction2(someParams);
    } else if (param.equals(value3)) { 
        doAction3(someParams);
    }
    // ...

可重构为：

JAVA

Map<?, Function<?> action> actionMappings = new HashMap<>();  // 这里泛型 ? 是为方便演示，实际可替换为你需要的类型
    
    // When init
    actionMappings.put(value1, (someParams) -> {  doAction1(someParams)});
    actionMappings.put(value2, (someParams) -> {  doAction2(someParams)});
    actionMappings.put(value3, (someParams) -> {  doAction3(someParams)});
    
    // 省略 null 判断
    actionMappings.get(param).apply(someParams);

C++

std::map<int, std::function<int(para)>> func_;
    
    func_ = { 
        { value1, [&](para){ return doAction1(para);}},
        { value2, [&](para){ return doAction2(para);}},
        { value3, [&](para){ return doAction3(para);}}
    }
    
    int add(int value)
    { 
        auto func = func_.find(value);
        if (func == func_.end()) { 
            return ERROR;
        }
    
        return func->second(para);
    }

表的映射关系，可以采用集中的方式，也可以采用分散的方式，即每个处理类自行注册。也可以通过配置文件的方式表达。总之，形式有很多。

## 2 if…else 嵌套过深 ##

### 2.1 问题表现 ###

`if...else` 多通常并不是最严重的的问题。有的代码 `if...else` 不仅个数多，而且 `if...else` 之间嵌套的很深，也很复杂，导致代码可读性很差、代码圈复杂度过高、稳定性变差，自然也就难以维护。

if (condition1) { 
        action1();
        if (condition2) { 
            action2();
            if (condition3) { 
                action3();
                if (condition4) { 
                    action4();
                }
            }
        }
    }

### 2.2 如何解决 ###

上一节介绍的方法也可用用来解决本节的问题，所以对于上面的方法，此节不做重复介绍。这一节重点介绍一些方法，这些方法并不会降低 `if...else` 的个数，但是会提高代码的可读性：

*  抽取方法
 *  卫语句

#### 2.2.1 抽取方法 ####

**介绍**  
抽取方法是代码重构的一种手段。定义很容易理解，就是将一段代码抽取出来，放入另一个单独定义的方法。 ——借用[重构指引][Link 1] 中的定义。

**适用场景**  
`if...else` 嵌套严重的代码，通常可读性很差。故在进行大型重构前，需先进行小幅调整，提高其代码可读性。抽取方法便是最常用的一种调整手段。

**实现与示例**  
重构前：

public void add(Object element) { 
      if (!readOnly) { 
        int newSize = size + 1;
        if (newSize > elements.length) { 
          Object[] newElements = new Object[elements.length + 10];
          for (int i = 0; i < size; i++) { 
            newElements[i] = elements[i];
          }
    
          elements = newElements
        }
        elements[size++] = element;
      }
    }

重构后：

public void add(Object element) { 
      if (readOnly) { 
        return;
      }
    
      if (overCapacity()) { 
        grow();
      }
    
      addElement(element);
    }

#### 2.2.2 卫语句 ####

在[重构指引][Link 2] 中，有一个方法被称为“使用卫语句替代嵌套条件语句”，可以大大降低嵌套次数，使圈复杂度降低。

重构前：

double getPayAmount() { 
        double result;
        if (_isDead) result = deadAmount();
        else { 
            if (_isSeparated) result = separatedAmount();
            else { 
                if (_isRetired) result = retiredAmount();
                else result = normalPayAmount();
            };
        }
        return result;
    }

重构后：

double getPayAmount() { 
        if (_isDead) return deadAmount();
        if (_isSeparated) return separatedAmount();
        if (_isRetired) return retiredAmount();
        return normalPayAmount();
    }

**使用场景**  
当看到一个方法中，某一层代码块都被一个 if…else 完整控制时，通常可以采用卫语句。

## 3 if…else 表达式过于复杂 ##

### 3.1 问题表现 ###

`if...else` 所导致的第三个问题来自过于复杂的条件表达式。下面给个简单的例子，当 condition 1、2、3、4 分别为 true、false，请大家排列组合一下下面表达式的结果。

if ((condition1 && condition2 ) || ((condition2 || condition3) && condition4)) { 
        ...
    }

我想没人愿意干上面的事情。关键是，这一长串表达式的含义是什么？当不知道表达式的含义时，没人愿意推断它的结果。

所以，表达式复杂，并不一定是错。但是表达式难以让人理解就不好了。

### 3.2 如何解决 ###

对于 `if...else` 表达式复杂的问题，主要用代码重构中的抽取方法、移动方法等手段解决。因为这些方法在《[重构指引][Link 2]》中都有介绍，所以这里不再赘述。

## 4 switch case分支过多 ##

`switch case`分支过多的解决思路与`if ..else`分支的解决基本一次，在此不在赘述，仅举一例：

重构前：

/** * 获取地市编码对应的地市名称 * * @param cityId 地市编码 * @return String 地市名称 */
    public static String getCityName(int cityId) { 
        switch (cityId) { 
            //苏州
            case GlobalDefine.DATUM_CITY_ID_SZ: { 
                return "sz";
            }
            //淮安
            case GlobalDefine.DATUM_CITY_ID_HA: { 
                return "hz";
            }
            //宿迁
            case GlobalDefine.DATUM_CITY_ID_SQ: { 
                return "sq";
            }
            //南京
            case GlobalDefine.DATUM_CITY_ID_NJ: { 
                return "nj";
            }
            //连云港
            case GlobalDefine.DATUM_CITY_ID_LYG: { 
                return "lyg";
            }
            //徐州
            case GlobalDefine.DATUM_CITY_ID_XZ: { 
                return "xz";
            }
            //常州
            case GlobalDefine.DATUM_CITY_ID_CZ: { 
                return "cz";
            }
            //镇江
            case GlobalDefine.DATUM_CITY_ID_ZJ: { 
                return "zj";
            }
            //无锡
            case GlobalDefine.DATUM_CITY_ID_WX: { 
                return "wx";
            }
            //南通
            case GlobalDefine.DATUM_CITY_ID_NT: { 
                return "nt";
            }
            //泰州
            case GlobalDefine.DATUM_CITY_ID_TZ: { 
                return "tz";
            }
            //盐城
            case GlobalDefine.DATUM_CITY_ID_YC: { 
                return "yc";
            }
            //扬州
            case GlobalDefine.DATUM_CITY_ID_YZ: { 
                return "yz";
            }
            //所有地市
            case GlobalDefine.DATUM_CITY_ALL: { 
                return "all";
            }
            default:
                return "";
        }
    }

重构后：

JAVA

/** * 获取地市编码对应的地市名称 * * @param cityId 地市编码 * @return String 地市名称 */
    public static String getCityName(int cityId) { 
    
        Map<Short, String> cityMap = new HashMap<Short, String>();
        //苏州
        cityMap.put(GlobalDefine.DATUM_CITY_ID_SZ, "sz");
    
        //淮安
        cityMap.put(GlobalDefine.DATUM_CITY_ID_HA, "ha");
    
        //宿迁
        cityMap.put(GlobalDefine.DATUM_CITY_ID_SQ, "sq");
    
        //南京
        cityMap.put(GlobalDefine.DATUM_CITY_ID_NJ, "nj");
    
        //连云港
        cityMap.put(GlobalDefine.DATUM_CITY_ID_LYG, "lyg");
    
        //徐州
        cityMap.put(GlobalDefine.DATUM_CITY_ID_XZ, "xz");
    
        //常州
        cityMap.put(GlobalDefine.DATUM_CITY_ID_CZ, "cz");
    
        //镇江
        cityMap.put(GlobalDefine.DATUM_CITY_ID_ZJ, "zj");
    
        //无锡
        cityMap.put(GlobalDefine.DATUM_CITY_ID_WX, "wx");
    
        //南通
        cityMap.put(GlobalDefine.DATUM_CITY_ID_NT, "nt");
    
        //泰州
        cityMap.put(GlobalDefine.DATUM_CITY_ID_TZ, "tz");
    
        //盐城
        cityMap.put(GlobalDefine.DATUM_CITY_ID_YC, "yc");
    
        //扬州
        cityMap.put(GlobalDefine.DATUM_CITY_ID_YZ, "yz");
    
        //所有地市
        cityMap.put(GlobalDefine.DATUM_CITY_ALL, "all");
    
        if (cityMap.containsKey((short) cityId)) { 
            return cityMap.get((short) cityId);
        } else { 
            return "cityId is error and not find this cityName by cityId";
        }
    }

C++

std::map<int, std::function<string>> func_;
    
    func_ = { 
        { GlobalDefine.DATUM_CITY_ID_SZ, [&](){ return "sz";}},
        { GlobalDefine.DATUM_CITY_ID_HA, [&](){ return "hz";}},
        { GlobalDefine.DATUM_CITY_ID_SQ, [&](){ return "sq";}},
        { GlobalDefine.DATUM_CITY_ID_NJ, [&](){ return "nj";}},
        { GlobalDefine.DATUM_CITY_ID_LYG, [&](){ return "lyg";}},
        { GlobalDefine.DATUM_CITY_ID_XZ, [&](){ return "xz";}},
        { GlobalDefine.DATUM_CITY_ID_CZ, [&](){ return "cz";}},
        { GlobalDefine.DATUM_CITY_ID_ZJ, [&](){ return "zj";}},
        { GlobalDefine.DATUM_CITY_ID_WX, [&](){ return "wx";}},
        { GlobalDefine.DATUM_CITY_ID_NT, [&](){ return "nt";}},
        { GlobalDefine.DATUM_CITY_ID_TZ, [&](){ return "tz";}},
        { GlobalDefine.DATUM_CITY_ID_YC, [&](){ return "yc";}},
        { GlobalDefine.DATUM_CITY_ID_YZ, [&](){ return "yz";}},
        { GlobalDefine.DATUM_CITY_ALL, [&](){ return "all";}}
    }
    
    string getCityName(int cityId)
    { 
        auto func = func_.find(cityId);
        if (func == func_.end()) { 
            return "";
        }
    
        return func->second();
    }

[Link 1]: https://refactoring.com/catalog/extractMethod.html
[Link 2]: https://refactoring.com/catalog/replaceNestedConditionalWithGuardClauses.html