写代码不用"if"行不行，曾经的反 if 运动

如果在IT行业的时间够长的话，可能还记得大约10几年前，设计模式风靡一时的时候，有过一段反 "if" 的运动。
所谓的反"if"运动，其实是夸大了"if"语句带来的问题，比如当时提出的问题有：

• 代码不好维护，特别是if或者else中的代码比较多的时候
  
• if和 else if分支太多的时候，代码难以阅读和修改
  
• 阅读含有if的代码时，必须在自己的头脑中模拟执行，会消耗你的精神能量
  
• ... ... 等等
  

这些问题确实存在，但是因为这些就彻底禁止if的话，就过于极端，因噎废食了。
代码中分支和循环是不可避免的，完全禁止if之后，在某些时候会产生了更加复杂和令人发指的代码，
所以，最后这个反"if"的运动也不了了之，慢慢消亡了。
不过，为了反"if"而产生的一些替代方案，我挑了三个还值得一看的方案，供大家参考参考。
其它还有很多方案都不太靠谱，就不一一赘述了。
1. 拆分成多个方法

这种重构"if"的方法是将每个分支单独封装成一个独立的方法。
比如：

1. def select_model(is_regression=True):
2.     if is_regression:
3.         print("选择【回归】模型")
4.     else:
5.         print("选择【分类】模型")
7. # 测试代码
8. select_model(True)
9. select_model(False)
11. # 运行结果
12. 选择【回归】模型
13. 选择【分类】模型

复制代码

示例中，方法select_model通过is_regression参数来决定调用哪种模型。
重构之后：

1. def select_regression():
2.         print("选择【回归】模型")
4. def select_classifier():
5.         print("选择【分类】模型")
7. # 测试代码
8. select_regression()
9. select_classifier()
11. # 运行结果
12. 选择【回归】模型
13. 选择【分类】模型

复制代码

将原方法拆分为两个新方法，"if"就消失了。
2. 改成多态

如果一个函数中分支比较多，比如：

1. def cry(animal):
2.     if animal == "dog":
3.         print("{} :汪汪~".format(animal))
4.     elif animal == "cat":
5.         print("{} :喵喵~".format(animal))
6.     elif animal == "sheep":
7.         print("{} :咩咩~".format(animal))
8.     elif animal == "cow":
9.         print("{} :哞哞~".format(animal))
10.     else:
11.         print("无法识别动物：{}".format(animal))
13. # 测试代码
14. cry("dog")
15. cry("cat")
16. cry("sheep")
17. cry("cow")
19. # 运行结果
20. dog :汪汪~
21. cat :喵喵~
22. sheep :咩咩~
23. cow :哞哞~

复制代码

cry函数根据不同的参数来判断输出内容，
如果分支多了，并且每个分支中的代码也比较多的时候，会比较难于维护。
对于上面的"if"分支较多的情况，可以用多态的方式来改造。
也就是，封装一个抽象类，其中包含抽象方法cry，然后不同的动物继承抽象类实现自己的cry方法。

1. from abc import ABCMeta, abstractclassmethod
3. class Animal(metaclass=ABCMeta):
4.     def __init__(self, name) -> None:
5.         self.name = name
7.     @abstractclassmethod
8.     def cry(self):
9.         pass
11. class Dog(Animal):
12.     def __init__(self) -> None:
13.         super().__init__("dog")
15.     def cry(self):
16.         print("{} :汪汪~".format(self.name))
19. class Cat(Animal):
20.     def __init__(self) -> None:
21.         super().__init__("cat")
23.     def cry(self):
24.         print("{} :喵喵~".format(self.name))
27. class Sheep(Animal):
28.     def __init__(self) -> None:
29.         super().__init__("sheep")
31.     def cry(self):
32.         print("{} :咩咩~".format(self.name))
35. class Cow(Animal):
36.     def __init__(self) -> None:
37.         super().__init__("cow")
39.     def cry(self):
40.         print("{} :哞哞~".format(self.name))
42. # 测试代码
43. animal = Dog()
44. animal.cry()
46. animal = Cat()
47. animal.cry()
49. animal = Sheep()
50. animal.cry()
52. animal = Cow()
53. animal.cry()
55. # 运行结果
56. dog :汪汪~
57. cat :喵喵~
58. sheep :咩咩~
59. cow :哞哞~

复制代码

3. 将条件判断内联

对于比较复杂的条件判断，可以用内联的方式的来改善。
比如，下面构造一个略微复杂的判断：

1. def complex_judge(foo, bar, baz):
2.     if foo:
3.         if bar:
4.             return True
6.     if baz:
7.         return True
8.     else:
9.         return False
11. # 测试代码
12. print(complex_judge(True, True, False))
13. print(complex_judge(True, False, False))
14. print(complex_judge(False, True, True))
16. # 运行结果
17. True
18. False
19. True

复制代码

这样写不仅阅读比较困难，增加或修改判断条件时也很麻烦。
用内联的方式（也就是用 and 和 or）修改后，简洁很多。

1. def complex_judge(foo, bar, baz):
2.     return foo and bar or baz
4. # 测试代码
5. print(complex_judge(True, True, False))
6. print(complex_judge(True, False, False))
7. print(complex_judge(False, True, True))
9. # 运行结果
10. True
11. False
12. True

复制代码

4. 总结

反"if"运动早已结束，对"if"彻底抛弃显得很荒谬，但也不能对此全盘否定。
"if"语句会影响阅读代码时流畅的思路，对代码中"if"的使用保持慎重的态度还是很有必要的。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！