3 powerful coding techniques to remove messy conditionals

In software development, we often encounter code logic that needs to handle multiple scenarios. If not managed properly, these logics can easily evolve into lengthy if-else chains or massive switch statements. This article will introduce several effective techniques to optimize these structures, improving code quality and maintainability.

1. Defensive programming: early return#

Let's say we're developing a user authentication system that needs to check various user statuses before allowing access:

This code has obvious structural issues. It uses deeply nested if-else structures, making the code difficult to read and maintain.As the number of condition checks increases, the indentation level of the code deepens, forming a so-called "arrow-shaped" code.Error handling logic is scattered across different nesting levels, which is not conducive to unified management.More importantly, the core logic of the code—the case where access is allowed—is buried deep within multiple layers of conditional judgments, lacking intuitiveness. This coding style not only reduces code readability but also increases the risk of errors and makes code expansion difficult.

We can optimize this code using the "early return" approach:

By adopting the "early return" strategy, we have successfully optimized the original code structure.

This method brings several improvements:

• It significantly reduces the nesting complexity of the code. Each condition check is handled independently, making the overall logic clearer and more understandable. This flattened structure not only improves code readability but also greatly reduces maintenance difficulty.
• This optimization method achieves centralized management of error handling logic. By returning results immediately after each condition check, we avoid unnecessary code execution while centralizing the handling of various error scenarios, making the entire error handling process more organized.
• The core logic of the code—the conditions for allowing access—becomes more prominent. This structure makes the main purpose of the code immediately apparent, greatly enhancing the expressiveness and comprehensibility of the code.

2. Lookup table method#

We often encounter scenarios where different results need to be returned based on different inputs. If not handled properly, these logics can easily evolve into lengthy if-else chains or massive switch statements. For example, in an e-commerce platform, we need to return corresponding status descriptions based on different order statuses:

This is a typical scenario of returning different results based on different cases. As the number of cases increases, the switch statement or if-else judgments become lengthy. Moreover, in this scenario, if users need to translate these status contents into other languages, it would require modifying the function body or adding new functions, which would bring significant maintenance costs.

In this case, we can use the lookup table method to optimize the code:

First, by using a Map object to store the mapping relationship between statuses and descriptions, the code becomes more concise. We've also made it easy to move status descriptions to configuration files, providing convenience for internationalization and dynamic updates. When new statuses are added, we don't need to modify the core logic code; we just need to add corresponding key-value pairs in the configuration.

3. Interface-oriented programming#

When developing large software systems, we often need to support multiple service providers or functional modules. We can consider using interface-oriented programming at the software design stage to facilitate subsequent expansions, thereby eliminating the complexity of multiple conditional judgments brought by hard-coding in complex systems.

Suppose we're developing a multilingual translation system that needs to support different translation service providers. If we don't consider interface-oriented programming from the design stage, subsequent expansions will become very difficult:

This implementation uses a simple and crude if-else structure to select translation providers, making the code difficult to maintain and expand. When adding new translation providers in the future, existing code needs to be modified, and as more translation providers need to be supported, the code will become bloated and hard to maintain. At the same time, this complex method is also difficult to unit test because it's not easy to simulate different translation providers.

To solve these problems, we can use interface-oriented programming to optimize the code. Interface-oriented programming is an important way to implement polymorphism, allowing different objects to respond differently to the same message.

Implementation process:

1. Define the translation strategy interface:

2. Implement this interface for each translation provider:

3. Refactor the TranslationService class, passing the strategy as a parameter:

4. Use the optimized code:

By defining the TranslationStrategy interface and introducing interface-oriented programming, we've gained the following benefits:

• TranslationService can use different translation strategies for each call.
• Adding new translation providers becomes simple, just create a new strategy class and implement the interface.
• Client code can flexibly choose the strategy to use for each translation without modifying the core logic of TranslationService.
• Each translation strategy can be tested independently, improving the testability of the code.
• Avoiding maintaining state in TranslationService makes the service more stateless and thread-safe.

Conclusion#

Optimizing conditional statement structures is an important means to improve code quality. The three methods introduced in this article—defensive programming, lookup table method, and interface-oriented programming (combined with polymorphism)—each have their applicable scenarios:

1. Defensive programming is suitable for handling multiple independent condition checks and can effectively reduce code nesting.
2. The lookup table method is suitable for handling requirements that react differently to different cases, making the code more concise and easier to maintain.
3. Interface-oriented programming combined with polymorphism is suitable for building complex but flexible systems, improving code flexibility and scalability.

In actual development, we often need to choose appropriate methods based on specific situations, and sometimes even need to comprehensively apply multiple techniques. The important thing is to balance the simplicity, readability, and maintainability of the code, choosing the solution that best fits the current problem.

Remember, over-optimization may lead to overly complex code. Keeping code simple and readable is always the primary principle. When applying these techniques, wise choices should be made based on the specific needs of the project and the technical level of the team.