## DEV Community is a community of 901,364 amazing developers

We're a place where coders share, stay up-to-date and grow their careers. Mofizur Rahman

Posted on • Originally published at blogs.moficodes.dev

# Go Crash Course Part VIII: if, switch and for

## If

In programming often we have to have conditional execution of certain statements. In most programming languages we have the idea of `if`.

``````var x = 10
if x > 5 {
fmt.Println("x is greater than 5")
}
``````

In this example we have a variable `x` which has value of 10. Then we check whether or not `x` is greater than 5. If it is, we print something. Otherwise we do nothing.

### if - else if - else

Often we are checking for more than one related thing. Lets take the example of FizzBuzz problem. For any number n, we want to print `Fizz` if n is divisible by 3, `Buzz` if n is divisible by 5, `FizzBuzz` if n is divisible by both 3 and 5 and n if its not divisible by either 3 or 5.

``````if n%15 == 0 {
fmt.Println("FizzBuzz")
} else if (n % 5) == 0 {
fmt.Println("Buzz")
} else if (n % 3) == 0 {
fmt.Println("Fizz")
} else {
fmt.Println(n)
}
``````

We can chain as many if-else if as we want. else is a special case where we do not have to have a conditional operator. It matches the case that no if - else if conditions match.

It is almost always possible to skip the else branch in functions. For example

``````func isEven(n int) bool {
if n%2 == 1 {
return false
}
return true
}
``````

Instead of having a else block we can just return the default case.

### If with statement

Sometimes we want to check some condition of variable we just created and we only need the variable for the condition. An example might help clear this up a bit more.

``````func minRand(min int) int {
rand.Seed(time.Now().UnixNano())
if v := rand.Int(); v > min {
return v
}
return min
}
``````

We have a random number `v` and if v is greater than `min` we return `v` if not we would just return `min`. We do not need access to `v` outside the if condition. This helps us with readability as well as variable naming. In go we are not allowed to redefine a variable with a different type. In a large function having every variable in the same scope might cause trouble.

## For

In programming we sometimes need to do something multiple times. We achieve this using loops. Go has only one construct for looping. It is the `for` keyword. But `for` is pretty versatile in go where we do not need anything else like `do-while`, `while` like in some other language.

### Anatomy of for

Generally a `for` loop has this structure

``````for i := 0; i < 100; i++ {
}
``````

We have a init that initializes our loop invariant. Then we have a condition that is used to terminate the loop and we have a change that is run after each loop iteration.

All three of these are optional and can be used or omitted as we need.

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

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

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

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

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

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

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

i = 0
for {
if i >= 5 {
break
}
fmt.Println(i)
i++
}
``````

These are all possible combination of a for loop with a single invariant. All of these for loop do the exact same thing.

### Break

At any point in the `for` execution we can use the `break` statement to break out of the closest `for` loop.

### Mutli invariant for loop

We can also have for loops where we have two variables.

``````for i, j := 0, 10; i != j; i, j = i+1, j-1 {
fmt.Println(i, j)
}
``````

The basic structure is the same. We have a init where we initialize `i` and `j`. Condition to chech `i != j` and then we increase `i` and decrease `j`.

### Forever

If we run a for loop with no exit condition we runt he for loop forever. There are times we want to run a process indefinitely.

``````for{
// do work indefinitely
}
``````

For example if we look at the source code for net/http we can see an example of indefinite for loop that waits for new connection to server.

## Next Steps

This is Part 8 of this Go crash course series.