重构—改善既有代码的设计009：简化条件表达式（Simplifying Conditional Expressions）

最新推荐文章于 2018-11-02 09:45:21 发布

原创最新推荐文章于 2018-11-02 09:45:21 发布 · 991 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#string #security #nested #null #object

设计模式专栏收录该内容

19 篇文章

订阅专栏

本文介绍了一系列重构技巧，旨在简化条件表达式，包括分解条件、合并条件表达式、消除重复条件分支等，通过具体示例展示了如何改善既有代码的设计。

重构—改善既有代码的设计009：简化条件表达式（Simplifying Conditional Expressions）

一：DECOMPOSE CONDITIONAL
二：CONSOLIDATE CONDITIONAL EXPRESSION
三：CONSOLIDATE DUPLICATE CONDITIONAL
四：REMOVE CONTROL FLAG
五：REPLACE NESTED CONDITIONAL WITH GUARD CLAUSES
六：RPLACE CONDITIONAL WITH POLYMORPHISM
七：INTRODUCE NULL OBJECT
八：INTRODUCT ASSERTION

一：DECOMPOSE CONDITIONAL
    1：从IF，THEN，ELSE三个段落中分别提炼出独立函数
        if (date.before(SUMMER_START) || data.after(SUMMER_END))
        {
            charge = quantity * _winterRate + _winterServiceCharge;
        }
        else
        {
            charge = quantity * _summerRate;
        }
        改为：
        if (notSummer(date))
        {
            charge = winterCharge(quantity);
        }
        else
        {
            charge = summerCharge(quantity);
        }
    2：动机
        大型函数自身会使代码的可读性下降，而条件逻辑则会使代码更难阅读
        和任何大块头代码一样，你可以将它们分解为多个独立的函数，根据每个小块代码的用途为分解而的到的新函数命名。
        对于条件逻辑，可以突出条件逻辑，更清楚地表明每个分支的作用，突出每个分支的原因。
    3：做法
        .将IF段落提炼出来，构成一个独立函数
        .将THEN段落和ELSE段落都提炼出来，各自构成一个独立函数
    4：实例
        if (date.before(SUMMER_START) || data.after(SUMMER_END))
        {
            charge = quantity * _winterRate + _winterServiceCharge;
        }
        else
        {
            charge = quantity * _summerRate;
        }
        改为：
        if (notSummer(date))
        {
            charge = winterCharge(quantity);
        }
        else
        {
            charge = summerCharge(quantity);
        }
        private Boolean notSummer(Date data)
        {
            return date.before(SUMMER_START) || data.after(SUMMER_END);
        }
        private Double winterCharge(int quantity)
        {
            return quantity * _winterRate + _winterServiceCharge;
        }
        private Double summerCharge(int quantity)
        {
            return quantity * _summerRate;
        }

二：CONSOLIDATE CONDITIONAL EXPRESSION
    1：将这些测试合并为一个条件式，并将这个条件式提炼成为一个独立函数
        double disabilityAmount()
        {
            if (_security < 2)
            {
                return 0;
            }
            if (_monthsDisabled > 12)
            {
                return 0;
            }
            if (_isPartTime)
            {
                return 0;
            }
        }
        改为：
        double disabilityAmount()
        {
            if (isNotEligableFordisability())
            {
                return 0;
            }
        }
    2：动机
        一串条件检查，检查条件各不相同，最终行为一致，这是可以用了。
        但是如果这些检查的确彼此独立，的确不应该视为同一次检查，则不要用了。
    3：做法
        .确定这些条件都没有副作用（连带影响）
        .使用适当的逻辑操作符将一序列相关条件合并为一个
        .编译，测试
        .对合并后的条件实施EXTRACT METHOD
    4：范例
        double disabilityAmount()
        {
            if (_security < 2)
            {
                return 0;
            }
            if (_monthsDisabled > 12)
            {
                return 0;
            }
            if (_isPartTime)
            {
                return 0;
            }
        }
        改为：
        double disabilityAmount()
        {
            if (isNotEligableFordisability())
            {
                return 0;
            }
        }
        Boolean isNotEligableFordisability()
        {
            return (_security < 2) || (_monthsDisabled > 12) || (_isPartTime);
        }

三：CONSOLIDATE DUPLICATE CONDITIONAL
    1：在条件式的每个分支上有着相同的一段代码，将这段重复代码搬移到条件式之外
        if (isSpecialDeal())
        {
            total = price * 0.05;
            send();
        }
        else
        {
            total = price * 0.99;
            send();
        }
        改为：
        if (isSpecialDeal())
        {
            total = price * 0.05;
        }
        else
        {
            total = price * 0.99;
        }
        send();
    2：动机
        如果一组条件式的所有分支都执行了相同的某段代码，这时就应该将这段代码搬移到条件式外面。
        这样，代码才能更清楚地表明哪些东西随条件变化而变化，哪些东西是保持不变的。
    3：做法
        .鉴别出执行方式不随条件变化而变化的代码
        .如果这些共同代码位于条件式的起始处，将将它移到条件式之前
        .如果这些共同代码位于条件式的尾端，就将它移到条件式之后
        .如果这些共同代码位于条件式中段，就需要观察共同代码之前或之后的代码是否改变了什么东西，如果改变了，需要小心处理
        .如果共同代码时多行，则用EXTRACT METHOD方法提炼
    4：范例
        如上

四：REMOVE CONTROL FLAG
    1：在一序列布尔表达式中，变量控制，以BREAK或RETURN语句替代
    2：单一入口原则会在代码中加入讨厌的控制标记，大大降低程序的可读性。可以用BREAK和CONTINUE跳出复杂条件语句。使代码清晰
        void checkSecurity(String[] people)
        {
            Boolean found = false;
            for (int index = 0; index < people.Length;index++ )
            {
                if (!found)
                {
                    if (people[index].Equals("Don"))
                    {
                        found = true;
                    }
                    else if (people[index].Equals("John"))
                    {
                        found = true;
                    }
                }
            }
        }
        改成：
        void checkSecurity(String[] people)
        {
            for (int index = 0; index < people.Length; index++)
            {
                if (people[index].Equals("Don"))
                {
                    break;
                }
                else if (people[index].Equals("John"))
                {
                    break;
                }
            }
        }
    3：以RETURN返回控制标记
       void checkSecurity(String[] people)
        {
            Boolean found = false;
            for (int index = 0; index < people.Length;index++ )
            {
                if (!found)
                {
                    if (people[index].Equals("Don"))
                    {
                        found = true;
                    }
                    else if (people[index].Equals("John"))
                    {
                        found = true;
                    }
                }
            }
            someLaterCode(found);
        }
        改成：将 someLaterCode(found);参数BOOLEAN改成对字符串是否为空的判断即可
        void checkSecurity(String[] people)
        {
            String found = foundMiscreant(people);
            someLaterCode(found);

        }
        void foundMiscreant(String[] people)
        {
            for (int index = 0; index < people.Length; index++)
            {
                if (people[index].Equals("Don"))
                {
                    return "Don";
                }
                else if (people[index].Equals("John"))
                {
                    return "John";
                }
            }
            return "";
        }

五：REPLACE NESTED CONDITIONAL WITH GUARD CLAUSES以卫语句取代嵌套条件式
    1：函数中的条件逻辑使人难以看清正常的执行路径
        Double getPayAmount()
        {
            if (!_isDead)
            {
                result = deadAmount();
            }
            else if (!_isSeparated)
            {
                result = seperatedAmount();
            }
            else if (!_isRetired)
            {
                result = retiredAmount();
            }
            else
            {
                result = normalPayAmount();
            }
            return result;
        }
        改成：
        Double getPayAmount()
        {
            if (!_isDead)
            {
                return deadAmount();
            }
            else if (!_isSeparated)
            {
                return seperatedAmount();
            }
            else if (!_isRetired)
            {
                return retiredAmount();
            }
            else
            {
                return normalPayAmount();
            }
        }
    2：卫语句：如果某个条件及其罕见，就应该单独检查条件，并在该条件为真时从函数中返回（或抛出异常）。这样的单独检查称为“卫语句”
        即给某条分支以特别的重视，如果用IF THEN ELSE，则所有分支都是同等的。
        而卫语句告诉读者，这种情况很少见，如果它真的发生了，请做一些必要的整理工作，然后退出。
        这个会破坏函数单一出口原则，但是可以提高代码的清晰度