Control Flow: Conditionals and Loops

Control flow in Go is handled through conditionals and loops. These structures allow you to make decisions (if-else) and repeat actions (loops) in your program. With control flow, you can write dynamic programs that react to specific conditions and execute repetitive tasks.

In this module, you'll learn how to:

• Use if, else, and switch statements for conditional logic.
• Understand the for loop for iteration.
• Implement break, continue, and goto for controlling loop execution.

Main Concepts of Control Flow in Go

1. If and Else Statements:

   • if allows conditional execution based on a boolean expression. You can chain conditions using else if and else.

   if age >= 18 {
       fmt.Println("You are an adult.")
   } else {
       fmt.Println("You are a minor.")
   }
   

2. Switch Statements:

   • switch is a cleaner alternative to multiple if statements. It can evaluate a single expression and compare it against multiple cases.

   switch day := "Monday"; day {
   case "Monday":
       fmt.Println("Start of the week!")
   case "Friday":
       fmt.Println("End of the week!")
   default:
       fmt.Println("Midweek!")
   }
   

3. For Loop:

   • Go has only one loop construct: for. It can be used in several forms:
     • Traditional for loop (like C, Java, or JavaScript):

       for i := 0; i < 5; i++ {
           fmt.Println(i)
       }
       

     • For-while loop (no initialization and condition):

       i := 0
       for i < 5 {
           fmt.Println(i)
           i++
       }
       

     • Infinite loop (use for with no condition):

       for {
           fmt.Println("Infinite loop!")
       }
       

4. Break and Continue:

   • break exits the loop immediately, while continue skips the current iteration and moves to the next one.

   for i := 0; i < 10; i++ {
       if i == 5 {
           break
       }
       fmt.Println(i)
   }
   

   for i := 0; i < 10; i++ {
       if i%2 == 0 {
           continue
       }
       fmt.Println(i)
   }
   

5. Goto Statement:

   • The goto statement transfers control to a labeled statement within the same function. Use this sparingly, as it can make code hard to follow.

   func main() {
       i := 0
       loop:
           fmt.Println(i)
           i++
           if i < 5 {
               goto loop
           }
   }
   

Practical Applications of Control Flow in Go

Task: Age Classification Program

1. Write a program that takes a user’s age as input and prints whether they are a minor, adult, or senior citizen.

   var age int
   fmt.Println("Enter your age:")
   fmt.Scan(&age)
   if age < 18 {
       fmt.Println("You are a minor.")
   } else if age < 65 {
       fmt.Println("You are an adult.")
   } else {
       fmt.Println("You are a senior citizen.")
   }
   

Task: Weekday Printer

1. Create a program that uses a switch statement to print the type of the day (e.g., weekend, weekday).

   var day = "Saturday"
   switch day {
   case "Saturday", "Sunday":
       fmt.Println("It's a weekend!")
   default:
       fmt.Println("It's a weekday.")
   }
   

Task: FizzBuzz Program

1. Write a program that prints numbers from 1 to 100. For multiples of 3, print 'Fizz', for multiples of 5, print 'Buzz', and for multiples of both, print 'FizzBuzz'.

   for i := 1; i <= 100; i++ {
       if i%3 == 0 && i%5 == 0 {
           fmt.Println("FizzBuzz")
       } else if i%3 == 0 {
           fmt.Println("Fizz")
       } else if i%5 == 0 {
           fmt.Println("Buzz")
       } else {
           fmt.Println(i)
       }
   }
   

Task: Odd/Even Printer

1. Write a program that prints numbers from 1 to 10 and labels them as either odd or even.

   for i := 1; i <= 10; i++ {
       if i%2 == 0 {
           fmt.Println(i, "is even")
       } else {
           fmt.Println(i, "is odd")
       }
   }
   

Task: Sum of Numbers

1. Write a program that sums numbers from 1 to 100, but skips numbers divisible by 7.

   sum := 0
   for i := 1; i <= 100; i++ {
       if i%7 == 0 {
           continue
       }
       sum += i
   }
   fmt.Println("Sum of numbers from 1 to 100 (excluding multiples of 7):", sum)
   

Advanced Insights into Go Control Flow

1. Multiple Conditions in If Statements:

   • Go allows logical operators (&& for AND, || for OR) in conditionals, enabling more complex decision-making.

   if age >= 18 && age <= 65 {
       fmt.Println("You are an adult.")
   }
   

2. Fallthrough in Switch Statements:

   • By default, Go’s switch statements stop executing after the first matching case. Use the fallthrough keyword to make Go execute the subsequent case as well.

   switch day := "Sunday"; day {
   case "Sunday":
       fmt.Println("It's a weekend!")
       fallthrough
   case "Saturday":
       fmt.Println("Enjoy your day!")
   }
   

3. Labeling Loops with Break and Continue:

   • You can label outer loops and use break and continue to control them from within inner loops.

   outerLoop:
   for i := 0; i < 10; i++ {
       for j := 0; j < 10; j++ {
           if i == 5 && j == 5 {
               break outerLoop
           }
           fmt.Println(i, j)
       }
   }
   

4. Go’s For Loop as a While Loop:

   • Go does not have a while loop. However, the for loop can be used as a while loop by omitting initialization and post statements.

   i := 0
   for i < 5 {
       fmt.Println(i)
       i++
   }
   

5. Using Goto for Flow Control:

   • Though discouraged, goto allows you to jump to a labeled section of code. Use it cautiously, as it can make code less readable.

   loop:
       fmt.Println("This is a loop.")
       goto loop
   

Additional Resources for Control Flow in Go

• Go Conditionals and Loops: Go Docs - Control Flow
• Go Switch Statements: Go Switch Documentation
• Go Break and Continue: Go Break and Continue Docs

These resources will further enhance your understanding of Go’s control flow mechanisms.