改善代码设计 —— 简化条件表达式(Simplifying Conditional Expressions)
1. Decompose Conditional (分解条件式)
解释: "复杂的条件逻辑" 是导致复杂性上升最常见的地方, "条件表达式中堆积的计算过程", "条件式表达得不简洁"等等都是造成复杂的原因. Decompose Conditional 用于将这些复杂的元素从条件表达式中分离出去, 仅在条件表达式中调用简洁的函数.
这样做带来的直接好处是减少重复, 而且代码的可读性提高了.
冲动前:0 if (date.After(SUMMER_START) && date.Before(SUMMER_END))
1 charge = days * _price + _summerServiceTip;
2 else
3 charge = days * _price;
冲动后:0 if (date.IsSummer())
1 charge = SummerCharge(days);
2 else
3 charge = WinterCharge(days);
2. Consolidate Conditional Expression (合并条件式)
解释: 如果代码中有一连串的 if 检查语句, 检查语句中的条件不相同, 但最终的行为都是一样的. 对于这样的情况, 应该使用 "逻辑与" 和 "逻辑或" 将它们合并成一个条件表达式, 如果嫌这个合并条件后的表达式太罗嗦, 你还可以将这个表达式提取成一个函数.
冲动前:0 if (computer.CPU != "T6670")
1 return false;
2 if (computer.RAM != "1.00GB")
3 return false;
4 if (computer.SytemType != "32-bit Operating System")
5 return false;
6 //other compution
冲动后:0 if ((computer.CPU != "T6670") || (computer.RAM != "1.00GB") || (computer.SytemType != "32-bit Operating System"))
1 return false;
2 //other compution
你还可以将 if 里长长的条件表达式提取成一个方法, 如 bool IsStandard(Computer computer), 这样在原来的 if 语句中只需要调用这个方法即可
3. Consolidate Duplicate Conditional Fragments (合并重复的条件片段)
解释: 如果条件式的每个分支上都有同样一段代码, 如果这段代码对条件分支在执行这段代码后执行后面的代码没有影响, 请将这段代码移到条件式的外面.
冲动前:00 if (date.IsSummer())
01 {
02 charge = days * _price + _summerServiceTip;
03 PrintDetail();
04 }
05 else
06 {
07 charge = days * _price;
08 PrintDetail();
09 }
10 //other compution
冲动后:0 charge = days * _price;
1
2 if (date.IsSummer())
3 charge += _summerServiceTip;
4
5 PrintDetail();
6 //other compution
4. Remove Control Flag (移除控制标志)
解释: 很多代码里执行一个 for 或者 while 循环用于寻找一个数组里特点的元素, 很多时候在循环开头就执行控制标志的检查, 满足检查条件就继续执行循环查找元素. 如果这一次查找到了想要的元素, 就更改控制标志的值, 让它下次被检查出不符合条件, 从而循环结束.
这并不是一个很好的做法, 使用诸如 break, continue, return 语句会让你的代码意图更加直接, 更加明显.
冲动前:00 for (int i = 0; i < suspects.Length; i++)
01 {
02 if (!found)
03 {
04 if (suspects[i].Name == guessName)
05 {
06 sendAlert();
07 found = true;
08 }
09 }
10
11 }
冲动后:0 for (int i = 0; i < suspects.Length; i++)
1 {
2 if (suspects[i].Name == guessName)
3 {
4 sendAlert();
5 break;
6 }
7 }
5. Replace Nested Conditional with Guard Clauses (以卫语句取代嵌套条件式)
解释: 许多程序员觉得函数应该只有一个出口 (return), 结果导致函数中的条件逻辑 (Conditional Logic) 本来完全可以终止下面的代码继续执行 (因为没有必要), 结果却只在函数最后 return, 使人难以看清程序的执行路径.
Replace Nested Conditional with Guard Clauses 用来解决这个问题, 它能带给代码可读性的提高, 还有性能上一点点的优化.
冲动前:00 double charge;
01
02 if (IsSummer(date))
03 {
04 //...
05 SummerCharge(charge);
06 }
07 else
08 {
09 //...
10 WinterCharge(charge);
11 }
12
13 return charge;
冲动后:00 double charge;
01
02 if (IsSummer(date))
03 {
04 //...
05 SummerCharge(charge);
06 return charge;
07 }
08 else
09 {
10 //...
11 WinterCharge(charge);
12 return charge;
13 }
6. Replace Conditional with Polymorphism (以多态取代条件)
解释: 这条重构手法常常用于消除函数中长长的 switch-case 语句. 虽然写一个个的子类比较繁琐, 但随着项目的进行, 好处会体现出来的.
冲动前:00 public double Salary(Employee employee)
01 {
02 switch(employee.Type):
03 {
04 case Employee.Engineer
05 {
06 //...
07 }
08 case Employee.Salesman:
09 {
10 //...
11 }
12 //...
13 default:
14 {
15 //...
16 }
17 }
18 }
冲动后:00 public abstract double Salary(Employee employee);
01
02 class Engineer : Employee
03 {
04 public override double Salary(Employee employee)
05 {
06 //...
07 }
08 }
09 class Salesman : Employee
10 {
11
补充：综合编程 , 其他综合 ,
