【收藏】 The Simplest Anti-IF Code

最新推荐文章于 2023-09-26 22:37:43 发布

最新推荐文章于 2023-09-26 22:37:43 发布 · 76 阅读

本文探讨了IF语句如何增加代码间的耦合性和降低可读性，并通过实例展示了如何利用面向对象的设计原则，如继承和多态，来重构代码以提高其灵活性和可维护性。

原文地址：The Simplest Anti-IF Code

The basic problem is that IFs create dependencies, coupling between modules (methods, objects, components, etc.) and increases possible paths inside our code (which reduces legibility).

An IF seems like a quick and easy way to make changes, but for the reasons listed above, IF after IF, we create software full of duplications that can’t be modified.

Here’s a simple example:

                // Bond class
                double calculateValue() {
                       if(_type == BTP)  { 

                        return calculateBTPValue();
                       } else if(_type == BOT) { 
                                 return calculateBOTValue();    
                              } else {
                                 return calculateEUBValue();
                              }
                }

Every change in bond type, for example, a new bond to evaluate, leads to a modification in our piece of code. Imagine what it would take to modify methods with built-in IFs and SWITCHes!

                 // Bond class
                double calculateValue() {
                    _bondProfile.calculate();
                }

                // AbstractBondProfile class

                abstract double calculate();

                // classe BTPBondProfile >> AbstractBondProfile
                double calculate() {
                    ...
                }
                // classe BOTBondProfile >> AbstractBondProfile
                double calculate() {
                    ...
                }

                // classe EUBondProfile >> AbstractBondProfile
                double calculate() {
                    ...
                }

What do we gain by taking out IFs?

The advantage is that tomorrow, we can fulfill the request for a new type of bond by simply creating a new class, with the single required logic to calculate the value of that new bond.

The solution isn’t always to create a new abstract class or an interface. But the solution will always make the software flexible, communicative, testable, ready for change.