Let’s talk about flow control, starting with if/else.
If/Else
This works pretty much the same as you expect but the expression doesn’t need to be surrounded by parentheses ().
func main()
x := 10
if x > 5
fmt.Println("x is gt 5")
else if x > 10
fmt.Println("x is gt 10")
else
fmt.Println("else case")
$ go run main.go
x is gt 5
Compact if
We can also compact our if statements.
func main()
if x := 10; x > 5
fmt.Println("x is gt 5")
Note: This pattern is quite common
Switch
Next, we have switch statement, which is often a shorter way to write conditional logic.
In Go, the switch case only runs the first case whose value is equal to the condition expression and not all the cases that follow. Hence, unlike other languages, break statement is automatically added at the end of each case.
This means that it evaluates cases from top to bottom, stopping when a case succeeds.
Let’s take a look at an example:
func main()
day := "monday"
switch day
case "monday":
fmt.Println("time to work!")
case "friday":
fmt.Println("let's party")
default:
fmt.Println("browse memes")
$ go run main.go
time to work!
Switch also supports shorthand declaration like this.
switch day := "monday"; day
case "monday":
fmt.Println("time to work!")
case "friday":
fmt.Println("let's party")
default:
fmt.Println("browse memes")
We can also use the fallthrough keyword to transfer control to the next case even though the current case might have matched.
switch day := "monday"; day
case "monday":
fmt.Println("time to work!")
fallthrough
case "friday":
fmt.Println("let's party")
default:
fmt.Println("browse memes")
And if we run this, we’ll see that after the first case matches the switch statement continues to the next case because of the fallthrough keyword.
$ go run main.go
time to work!
let's party
We can also use it without any condition, which is the same as switch true.
x := 10
switch
case x > 5:
fmt.Println("x is greater")
default:
fmt.Println("x is not greater")
Loops
Now, let’s turn our attention toward loops.
So in Go, we only have one type of loop which is the for loop.
But it’s incredibly versatile. Same as if statement, for loop, doesn’t need any parenthesis () unlike other languages.
For loop
Let’s start with the basic for loop.
func main()
for i := 0; i < 10; i++
fmt.Println(i)
The basic for loop has three components separated by semicolons:
- init statement: which is executed before the first iteration.
- condition expression: which is evaluated before every iteration.
- post statement: which is executed at the end of every iteration.
Break and continue
As expected, Go also supports both break and continue statements for loop control. Let’s try a quick example:
func main()
for i := 0; i < 10; i++
if i < 2
continue
fmt.Println(i)
if i > 5
break
fmt.Println("We broke out!")
So, the continue statement is used when we want to skip the remaining portion of the loop, and break statement is used when we want to break out of the loop.
Also, Init and post statements are optional, hence we can make our for loop behave like a while loop as well.
func main()
i := 0
for ;i < 10;
i += 1
Note: we can also remove the additional semi-colons to make it a little cleaner
Forever loop
Lastly, If we omit the loop condition, it loops forever, so an infinite loop can be compactly expressed. This is also known as the forever loop.
func main()
for
// do stuff here
This article is part of my open source Go Course available on Github.
Master the fundamentals and advanced features of the Go programming language
Hey, welcome to the course, and thanks for learning Go. I hope this course provides a great learning experience.
This course is also available on my website as well as on Educative.io
Go (also known as Golang) is a programming language developed at Google in 2007 and open-sourced in 2009.
It focuses on simplicity, reliability, and efficiency. It was designed to combine the efficacy, speed, and safety of a statically typed and compiled language with the ease of programming of a dynamic language to…