![[SOLVED] Using golang while loop with Examples](/golang-while-loop/golang_while_loop.jpg)
Using usage of golang while loop
Go does not offer thewhilekeyword for writingwhileloops but allows you to use aforloop instead of awhileloop.
A while loop in Go is a loop construct, where a block of code will be executed until a condition turns to false. While loops are mostly used in scenarios where we are not certain how many loop cycles we need. Unlike other programming languages like Python which have a while keyword to define a while loop, Go uses the for loop construct to define a while. In Go a basic loop would look like below.
for initialization; condition expression post statement {
code to execute
}
Here,
- An
initstatement: This statement is executed before the first iteration starts. (Each time theforstatement executes the statements contained within it is called aniteration.) - A
conditionexpression: This expression is evaluated before the iteration starts to determine if the iteration should continue. - A
poststatement: This statement is evaluated at the end of each iteration.
However, theforloop can also emulate ado...whileloop, which can be
found in other programming languages.
As an example, the following Go code is equivalent to
ado...while(anExpression)loop:
for ok := true; ok; ok = anExpression {
}
As soon as theokvariable has thefalsevalue, theforloop will terminate.
Understanding syntax of Go While Loop
Now , a Go while will make use of the for keyword and the initialization and omit the condition expression and the post statement. Below is the Go while loop syntax.
for condition {
code to execute
}
Example
package main
import "fmt"
func main() {
count := 0
for count < 5 {
fmt.Println("Count >>>", count)
count += 1
}
}
Explanation
In the above code sample, we first initialize the start of the loop
using the count variable. The next line defines the beginning of the
while loop. The condition in this while loop (count < 5) will
determine the number of loop cycles to be executed.
As long as the condition returns true, the block of code between {}
will be executed. Inside the while loop body, we increase the count
variable (count += 1) after every loop. It’s important to note that
without this statement, the while loop will run forever, which in many
cases is undesirable.
We will learn how to use the while loop with different data structures.
Output
$ go run main.go
Count >>> 0
Count >>> 1
Count >>> 2
Count >>> 3
Count >>> 4
Loop through struct elements using golang while loop
Go
struct data structure is a basic data store that is made up of a
collection of fields. We can use Go while loop with the struct types
when we are not sure how many fields we need to loop through. Other Go
loops like the basic for loop in Go can also be used to loop through
struct fields. For more information about that please read this
article. Since while
loops in Go require a condition, we need to find the number of fields
inside a struct to control the loop, otherwise the loop will execute
forever.
Example
package main
import (
"fmt"
"reflect"
)
type car struct {
Name string
Color string
Price int64
}
func main() {
c := car{
Name: "Subaru Outback",
Color: "Black",
Price: 9600,
}
values := reflect.ValueOf(c)
typesOf := values.Type()
size := values.NumField()
count := 0
for count < size {
fieldName := typesOf.Field(count).Name
fieldValue := values.Field(count).Interface()
fmt.Printf("%s : %v\n", fieldName, fieldValue)
count += 1
}
}
Explanation
In our preceding example, we define a struct with Name, Color and
Price fields of type string, string and integer respectively. In
the main function, we create an instance of a car struct. The values
variable stores the runtime data. This is made possible by the
reflect Go package. We can use the values variable
to access the field name field values and the number of fields from the
car instance. We then get the number of fields from the values
variable using size := values.NumField() statement and declare the
count variable with its initial value being 0 using the count := 0
statement.We then start the while loop using for count < size
statement. While looping we pull the field name and its corresponding
field value then print them on the console.
Output
$ go run main.go
Name : Subaru Outback
Color : Black
Price : 9600
Loop through Maps using golang while loop
Go Map is a collection of key-value pairs that are unordered, and provides developers with quick lookup, update and delete features. Go Maps can be used with a while loop , through its key-value pairs. Below is an example on how to use the while loop to iterate over Map key-value pairs.
Example
package main
import (
"fmt"
"reflect"
)
func main() {
user := map[string]string{
"firstName": "Mike",
"lastname": "joe",
"email": "mikejoe@golinuxcloud.com",
}
count := 0
keys := reflect.ValueOf(user).MapKeys()
for count < len(keys) {
key := fmt.Sprint(reflect.ValueOf(keys[count]).Interface())
value := user[key]
fmt.Printf("Key : %s Value : %s \n", key, value)
count += 1
}
}
Explanation
In the above code sample, we create a user instance of type map. We
define the count variable that defines the start of the loop. We then
define the keys variable that stores keys found in the user map. In
the while loop , we define a condition that checks if the count variable
is less than the length of the keys found in the map. When the condition
returns true, we store each respective key and convert it to string
types using this line
fmt.Sprint(reflect.ValueOf(keys[count]).Interface()). To obtain the
value for the key, we use the code value := user[key]. The print
statement prints the key and value from the map.Please note that the
order of the key value pair is unordered. Finally we ensure to increment
the count value by 1 every iteration using the code count += 1
Loop through slice elements using while loop
In Go, a slice is dynamically sized, flexible array type and the are more common than the arrays. We can use a while loop to iterate through elements of a slice. The below example demonstrates using a while loop in Go to loop through items in a slice.
Example
package main
import "fmt"
func main() {
numbers := [9]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
count := 0
for count < len(numbers) {
fmt.Printf("Index : %d ==> Item : %d \n", count, numbers[count])
count += 1
}
}
Explanation
In the preceding example, we initialize a slice with items of type int
and a count variable with its initial value being 0. We use the count
variable to keep track of the indexes in the int slice. We then start
the while loop that checks if the count is less than the number of
items in the slice. Using the Printf() function, we print the index
and the value of each item in the slice. At the end, we ensure to
increment the value of count after every iteration, without which the
loop will iterate forever.
Output
$ go run main.go
Index : 0 ==> Item : 1
Index : 1 ==> Item : 2
Index : 2 ==> Item : 3
Index : 3 ==> Item : 4
Index : 4 ==> Item : 5
Index : 5 ==> Item : 6
Index : 6 ==> Item : 7
Index : 7 ==> Item : 8
Index : 8 ==> Item : 9
Loop through string characters using while loop
String in Go is a sequence of characters , for example “Golinuxcloud.com” is a sequence of characters. We can use a while loop to iterate over a string while keeping track of the size of the string. In the following example , we use the while loop to iterate over a Go string.
Example
package main
import (
"fmt"
)
func main() {
goSite := "Hello, World!"
count := 0
for count < len(goSite) {
fmt.Printf("%d : %c \n", count, goSite[count])
count += 1
}
}
Explanation
We define the goSite variable that stores the "Hello, World!" string
and a count variable that will keep track of the indexes in the
string(<b>"</b>Hello, World!"). Using the Printf function from the
fmt package, we print the indexes with their respective characters. We
finally increment the count variable, without which the while loop will
iterate forever.
Output
$ go run main.go
0 : H
1 : e
2 : l
3 : l
4 : o
5 : ,
6 :
7 : W
8 : o
9 : r
10 : l
11 : d
12 : !
Loop through items of interface type using while loop
In Go, every type implements an empty interface. An empty interface is an interface without any methods. We can loop through a slice of items of type interface using the Go while loop.
Example
package main
import "fmt"
func main() {
items := [5]interface{}{"January", 3.244, false, 99, map[string]int{"age": 23}}
count := 0
for count < len(items) {
fmt.Printf("Index ==> %d Type ==> %T Value ==> %v \n", count, items[count], items[count])
count += 1
}
}
Output
$ go run main.go
Index ==> 0 Type ==> string Value ==> January
Index ==> 1 Type ==> float64 Value ==> 3.244
Index ==> 2 Type ==> bool Value ==> false
Index ==> 3 Type ==> int Value ==> 99
Index ==> 4 Type ==> map[string]int Value ==> map[age:23]
Loop through elements and store in golang channel
In Go, channels are typed conduits through which values are sent and
received using the channel operator <- . In the next example, we will
use the Go while loop to loop through strings and send them to a
channel.
Example
package main
import "fmt"
func testChannel(c chan string) {
colors := [5]string{"red", "yellow", "blue", "green", "black"}
count := 0
for count < len(colors) {
c <- colors[count]
count += 1
}
close(c)
}
func main() {
c := make(chan string, 10)
go testChannel(c)
for value := range c {
fmt.Println(value)
}
}
Explanation
In the above example, we create a slice of strings that get sent one by one to a channel of type string using a while loop. The loop will iterate until the count variable is no longer less than the number of strings in the colors slice.
Output
$ go run main.go
red
yellow
blue
green
black
Run infinite loop using while loop
An infinite while loop is a loop that does not have a stopping condition. The loop will continue iterating forever unless it is stopped by an external entity. In the next example we will create a while loop that sends elements and another receiving channel that prints endlessly.
Example
package main
import (
"fmt"
"time"
)
func msgSender(c chan string) {
for {
msg := fmt.Sprint("https://www.golinuxcloud.com is the best Go site")
time.Sleep(1 * time.Second)
c <- msg
}
}
func main() {
c := make(chan string)
go msgSender(c)
for value := range c {
fmt.Println(value)
}
}
Explanation
In the above example , we declare an infinite loop using the for
keyword without declaring a condition that will be checked. Messages
will be sent into the channel after every one second. In the main
function, the messages will be printed to the console after every
second. The loop will continue iterating until the you stop the script
from running by pressing the CTRL + C on the keyboard.
Output
$ go run main.go
https://www.golinuxcloud.com is the best Go site
https://www.golinuxcloud.com is the best Go site
https://www.golinuxcloud.com is the best Go site
^Csignal: interrupt
Using do..while loop (repeat until) in golang
As we discussed briefly during the introduction section, in golang we
can use for loop and execute a do..while condition. In this example
we will ask for user input and until we get a certain pre-defined input,
the loop should repeat itself.
package main
import "fmt"
var input int
func main() {
for ok := true; ok; ok = (input != 2) {
n, err := fmt.Scanln(&input)
if n < 1 || err != nil {
fmt.Println("invalid input")
break
}
switch input {
case 1:
fmt.Println("hi")
case 2:
// Do Something
default:
fmt.Println("I will print this if no match found!")
}
}
}
Summary
While loops are a key iterating feature in Go, and are mostly used in situations where we are not sure how many iterations we need. When using a while loop , it’s important to include a condition that will stop the loop , otherwise the loop will run forever. In this article, we learn how to use while loops through different data structures.
