Control Flow in Go: If-else statements, Switch case statements, Loops (for, while)

Control flow structures in Go allow you to make decisions and repeat actions in your programs. In this section, we’ll explore three fundamental control flow elements: if-else statements, switch case statements, and loops (for and while).

If-else Statements

If-else statements are used for decision-making in your code. They allow you to execute different blocks of code based on a given condition.

Basic If Statement

Here’s a simple example of an if statement:

var age int = 30

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

If-else Statement

An if-else statement lets you specify an alternative code block to execute when the condition is not met:

var temperature int = 25

if temperature >= 30 {
    fmt.Println("It's hot outside.")
} else {
    fmt.Println("It's not too hot.")
}

Switch Case Statements

Switch case statements provide a way to compare a value against multiple possible values and execute code blocks accordingly.

Basic Switch Statement

Here’s a basic example of a switch case statement:

var dayOfWeek int = 3

switch dayOfWeek {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday")
    case 3:
        fmt.Println("Wednesday")
    default:
        fmt.Println("Other day")
}

Loops

Loops in Go allow you to execute a block of code repeatedly. There are two primary types of loops in Go: the for loop and the while loop.

For Loop

The for loop in Go is versatile and can be used in various ways. Here’s an example of a basic for loop:

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

This loop will print the numbers from 0 to 4.

While Loop

Go doesn’t have a traditional while loop, but you can achieve the same functionality using a for loop:

num := 0

for num < 5 {
    fmt.Println(num)
    num++
}

This loop will also print the numbers from 0 to 4.

Control flow structures, including if-else statements, switch case statements, and loops, are essential for creating dynamic and decision-driven programs in Go. They enable you to control the flow of your code and handle different scenarios efficiently.