Control Structures: If, For, and Switch

Conditional Logic with if-else

Conditional statements allow your program to execute certain blocks of code only if a specific condition is met. Coming from Python and Bash, you're already very familiar with if/elif/else and if/elif/else/fi constructs. Go's syntax is similar but has a few key distinctions.

The most notable difference is that Go does not use parentheses () around conditions. Another powerful and idiomatic feature is the ability to include a "short statement" before the condition. This lets you initialize a variable that is scoped only to the if and any associated else blocks. This pattern is extremely common for error handling, which is central to robust Go programming.

As you saw in the article, this pattern is perfect for DevOps tasks where you might try to parse a configuration value or a command-line argument and need to handle the case where it fails.

// A common pattern for parsing input that might fail
if num, err := strconv.Atoi("10"); err == nil {
    // This block only runs if the conversion succeeded.
    // 'num' and 'err' are only accessible inside this if/else.
    fmt.Printf("Successfully converted to: %d\n", num)
} else {
    // This block runs if strconv.Atoi returned an error.
    fmt.Printf("Failed to convert: %v\n", err)
}

Looping with for

Go takes a minimalist approach to loops. Unlike Python, which has for and while, Go has only one looping keyword: for. However, it's versatile enough to cover all common looping scenarios.

1. The "while" loop: for condition { ... }
2. The traditional C-style loop: for init; condition; post { ... }
3. The "for-each" loop (most similar to Python's for..in): for index, value := range collection { ... }
4. The infinite loop: for { ... }

The following video breaks down these forms clearly.

Iterating with for...range

The for...range construct is likely to feel the most familiar to you. It's the idiomatic way to iterate over collections like slices, arrays, and maps.

A key detail from the video worth re-emphasizing is that when you use for index, value := range mySlice, the value variable is a copy of the element in the slice, not a reference to it. Modifying value inside the loop will not change the original slice.

Multi-way Branching with switch

When you have to check a variable against a series of possible values, a long chain of if-else if-else statements can become clumsy. Go's switch statement provides a cleaner, more readable alternative.

A crucial feature of Go's switch is that, unlike C or Java, it does not "fall through" from one case to the next. A break is automatically applied at the end of each case. If you explicitly want fallthrough behavior, you must use the fallthrough keyword.

Go's switch is also very flexible:

• You can list multiple values in a single case.
• You can use it without an expression (a "tagless switch"), where each case is simply a boolean condition. This provides a very clean alternative to a complex if-else if chain.

The combination of for and switch is very powerful for processing lists of items, as shown in this classic "FizzBuzz" example.

Hands-On Practice: Server Status Checker

Let's apply these concepts to a practical DevOps scenario. Create a new file named status_checker.go and write a program that simulates checking the status of several servers.

Your task:

1. Create a slice of strings containing a few server hostnames (e.g., web-01, db-01, cache-01, web-02).
2. Use a for...range loop to iterate over the slice.
3. Inside the loop, use a switch statement on the server name.
   • If the server name contains "db", print "[db-01] is in a critical state.".
   • If the server name is "cache-01", print "[cache-01] is running but has high memory usage.".
   • For any other server name, use the default case to print "[hostname] is running normally.".

Example Code Structure:

package main

import "fmt"

func main() {
    servers := []string{"web-01", "db-01", "cache-01", "web-02"}

    fmt.Println("--- Server Status Report ---")

    // Your for...range loop goes here
    for _, server := range servers {
        // Your switch statement goes here
        switch { // A tagless switch might be useful here if checking substrings!
        case server == "db-01": // Or something more flexible
            fmt.Printf("[%s] is in a critical state.\n", server)
        // Add more cases...
        default:
            fmt.Printf("[%s] is running normally.\n", server)
        }
    }
}

Hint: The strings.Contains() function might be useful for checking if a hostname includes "db". You'll need to add "strings" to your import statement to use it.

Run your code with go run status_checker.go and verify the output. Experiment by adding more servers to the slice.

Conclusion

You've now learned the essential tools for controlling the logic in your Go programs. These structures are the backbone of any non-trivial application.

Key Takeaways:

• if with Short Statements: The if statement; condition pattern is idiomatic Go for handling operations that might fail, keeping initialization and error-checking logic tightly scoped.
• The All-in-One for Loop: Go's single for keyword is flexible enough to act as a while loop, a traditional C-style for loop, and an iterator with for...range.
• Clean Branching with switch: switch statements offer a more readable alternative to long if-else chains, with safe, default break behavior and powerful "tagless" and multi-value case options.

Next Up

In this lesson, you saw how functions like strconv.Atoi or strings.Contains can be used within control structures. In the next lesson, you'll learn how to define and call your own functions. We will pay special attention to Go's ability to return multiple values, which is the mechanism that enables the clean error-handling pattern you practiced with if statements today.