Why You Should Not Use Else Statements in Your Code

In software engineering, how you structure your code shapes its readability, maintainability, and overall quality. One often-debated topic is the use of else statements. They look straightforward, and avoiding them still tends to produce cleaner, more understandable code. This post covers why you should reconsider using else statements, and what to reach for instead.

What is a guard clause?

Guard clauses are a powerful alternative to else statements. A guard clause is a condition at the beginning of a function that handles special cases or invalid input immediately, allowing the main logic to flow without nested conditions.

Example: using guard clauses

Here’s a simple example in Python to illustrate the concept:

1
def process_order(order):
2
    if order.is_valid():
3
        if order.has_stock():
4
            if order.is_paid():
5
                return "Order processed"
6
            else:
7
                return "Order not paid"
8
        else:
9
            return "Out of stock"
10
    else:
11
        return "Invalid order"

Notice how the nested conditions make the code harder to follow. Now let’s refactor it using guard clauses:

1
def process_order(order):
2
    if not order.is_valid():
3
        return "Invalid order"
4

5
    if not order.has_stock():
6
        return "Out of stock"
7

8
    if not order.is_paid():
9
        return "Order not paid"
10

11
    return "Order processed"

By handling special cases early, the main logic is clearer and easier to read. Guard clauses reduce indentation and put the main flow of the function up front.

How does it establish a contract?

Guard clauses also establish a clear contract for your functions. That means defining what conditions must be met before the function proceeds with its main logic.

When you handle edge cases at the beginning, the preconditions are immediately obvious, and the function’s behavior is more predictable and easier to understand.

Example: establishing a contract

Consider a function that processes user input:

1
def process_input(user_input):
2
    if user_input is None:
3
        raise ValueError("Input cannot be None")
4

5
    if not isinstance(user_input, str):
6
        raise TypeError("Input must be a string")
7

8
    if user_input == "":
9
        raise ValueError("Input cannot be empty")
10

11
    # Main processing logic
12
    return user_input.strip().upper()

With a contract set by guard clauses, the function’s main logic runs under clearly defined conditions. That makes the code both more readable and more reliable.

What about adding new conditions?

One of the challenges with else statements is that they lead to deeply nested code, especially as you add new conditions. Guard clauses let you add a condition without adding another level of indentation.

Example: adding new conditions with guard clauses

Suppose you need to extend the previous order processing function to check for a new condition, such as checking if the order is from a preferred customer:

1
def process_order(order):
2
    if not order.is_valid():
3
        return "Invalid order"
4

5
    if not order.has_stock():
6
        return "Out of stock"
7

8
    if not order.is_paid():
9
        return "Order not paid"
10

11
    if not order.is_preferred_customer():
12
        return "Standard order processing"
13

14
    return "Priority order processing"

Adding new conditions is straightforward and does not complicate the main logic flow. Each condition is handled explicitly and independently.

When can you use else?

Despite the advantages of avoiding else statements, there are situations where using else can be appropriate, especially when it improves readability or when dealing with mutually exclusive conditions that naturally fall into an if-else pattern.

Example: an appropriate use of else

For instance, in a simple function that classifies numbers, using else can make the code more concise and clear:

1
def classify_number(number):
2
    if number > 0:
3
        return "Positive"
4
    elif number < 0:
5
        return "Negative"
6
    else:
7
        return "Zero"

In this case, the else statement helps to clearly express the mutually exclusive nature of the conditions. The function is simple enough that the else statement doesn’t hurt readability.

Conclusion

Avoiding else statements leads to cleaner, more maintainable code, by using guard clauses and establishing clear contracts for your functions. By handling edge cases upfront and keeping the main logic straightforward, your code becomes easier to read and understand. However, remember that else statements are not inherently bad and can be useful in certain contexts, especially for mutually exclusive conditions.

References

1. Fowler, Martin. “Replace Nested Conditional with Guard Clauses.” Refactoring.com, https://refactoring.com/catalog/replaceNestedConditionalWithGuardClauses.html
2. “Refactoring Guru: Guard Clause.”), https://refactoring.guru/replace-nested-conditional-with-guard-clauses