Why We Should Avoid Using `else` in Programming

April 4, 2023 in category Golang Programming

The else keyword is a commonly used control structure in programming. It allows us to execute a block of code if a condition is not true. However, overusing else statements can lead to less readable and maintainable code. In this article, we’ll explore why we should avoid using else clauses in our code and look at some alternatives that can make our code more concise and readable.

Why Overusing `else` is a Bad Idea

One of the main arguments against using else statements is that they can make our code more complex and harder to read. As the number of conditions and branches increases, the code becomes harder to understand and maintain. Additionally, else clauses can make it difficult to follow the control flow of a program.

Another argument against using else clauses is that they can make our code more error-prone. For example, consider the following code:

if condition1() {
    // some code
} else if condition2() {
    // some code
} else if condition3() {
    // some code
} else {
    // some code
}

In this example, if one of the conditions is missed or written incorrectly, the code may not behave as expected. This can lead to subtle bugs that are difficult to detect and fix.

Alternatives to Using `else` Clauses

Using Early Returns

One way to avoid using else clauses is by using early returns. The idea behind this approach is to check for the error conditions first and return from the function if any error is detected.

Consider the following code:

initialVal := 10

if condition() {
   initialVal = 20
}

In this example, we have used an if statement to assign a value to initialVal if the condition() function is true. By avoiding the use of else, we have made our code more concise and readable than the alternative version with else:

initialVal := 0

if condition() {
   initialVal = 20
} else {
  initialVal = 10
}

Using Switch Statements

Another way to avoid using else clauses is by using switch statements. A switch statement is a control structure that allows us to execute different pieces of code based on the value of a variable.

Consider this example:

func printValue(x int) {
    switch {
    case x <= 0:
        fmt.Println("x is less than or equal to 0")
    case x <= 5:
        fmt.Println("x is greater than 0 but less than or equal to 5")
    case x <= 10:
        fmt.Println("x is greater than 5 but less than or equal to 10")
    default:
        fmt.Println("x is greater than 10")
    }
}

In this example, we have used switch statements to execute different pieces of code based on the value of x. We can see that the code is more readable than the previous example, and we can easily add more cases without making the code complex.

Using Guard Clauses

Guard clauses are another way to avoid using else clauses. The idea behind this approach is to check for the error conditions first and return from the function if any error is detected.

Consider this example:

func printValue(x int) {
    if x <= 0 {
        fmt.Println("x is less than or equal to 0")
        return
    }
    if x <= 5 {
        fmt.Println("x is greater than 0 but less than or equal to 5")
        return
    }
    if x <= 10 {
        fmt.Println("x is greater than 5 but less than or equal to 10")
        return
    }

    fmt.Println("x is greater than 10")
}

In this example, we have used guard clauses to check for the error conditions first and return from the function if any error is detected. We can see that the code is more concise and easier to read than the previous examples.

Conclusion

In this article, we have explored why we should avoid using else clauses in our code and looked at some alternatives that can make our code more concise and readable. By using early returns, switch statements, and guard clauses, we can make our code more maintainable and less error-prone. It’s important to keep in mind that while else clauses are not inherently bad, overusing them can make our code harder to read and maintain.