Now that we know how to use variables it's time to start writing some useful programs. First let's write a program that counts to 10, starting from 1, with each number on its own line. Using what we've learned so far we could write this:
package main
import "fmt"
func main() {
fmt.Println(1)
fmt.Println(2)
fmt.Println(3)
fmt.Println(4)
fmt.Println(5)
fmt.Println(6)
fmt.Println(7)
fmt.Println(8)
fmt.Println(9)
fmt.Println(10)
}Or this:
package main
import "fmt"
func main() {
fmt.Println(`1
2
3
4
5
6
7
8
9
10`)
}But both of these programs are pretty tedious to write. What we need is a way of doing something multiple times.
The for statement allows us to repeat a list of statements (a block) multiple times. Rewriting our previous program using a for statement looks like this:
package main
import "fmt"
func main() {
i := 1
for i <= 10 {
fmt.Println(i)
i = i + 1
}
}First we create a variable called i that we use to store the number we want to print. Then we create a for loop by using the keyword for, providing a conditional expression which is either true or false and finally supplying a block to execute. The for loop works like this:
We evaluate (run) the expression i <= 10 (“i less than or equal to 10”). If this evaluates to true then we run the statements inside of the block. Otherwise we jump to the next line of our program after the block. (in this case there is nothing after the for loop so we exit the program)
After we run the statements inside of the block we loop back to the beginning of the for statement and repeat step 1.
The i = i + 1 line is extremely important, because without it i <= 10 would always evaluate to true and our program would never stop. (When this happens this is referred to as an infinite loop)
As an exercise let's walk through the program like a computer would:
Create a variable named i with the value 1
Is i <= 10? Yes.
Print i
Set i to i + 1 (i now equals 2)
Is i <= 10? Yes.
Print i
Set i to i + 1 (i now equals 3)
…
Set i to i + 1 (i now equals 11)
Is i <= 10? No.
Nothing left to do, so exit
Other programming languages have a lot of different types of loops (while, do, until, foreach, …) but Go only has one that can be used in a variety of different ways. The previous program could also have been written like this:
func main() {
for i := 1; i <= 10; i++ {
fmt.Println(i)
}
}Now the conditional expression also contains two other statements with semicolons between them. First we have the variable initialization, then we have the condition to check each time and finally we “increment” the variable. (adding 1 to a variable is so common that we have a special operator: ++. Similarly subtracting 1 can be done with --)
We will see additional ways of using the for loop in later chapters.
Let's modify the program we just wrote so that instead of just printing the numbers 1-10 on each line it also specifies whether or not the number is even or odd. Like this:
1 odd 2 even 3 odd 4 even 5 odd 6 even 7 odd 8 even 9 odd 10 even
First we need a way of determining whether or not a number is even or odd. An easy way to tell is to divide the number by 2. If you have nothing left over then the number is even, otherwise it's odd. So how do we find the remainder after division in Go? We use the % operator. 1 % 2 equals 1, 2 % 2 equals 0, 3 % 2 equals 1 and so on.
Next we need a way of choosing to do different things based on a condition. For that we use the if statement:
if i % 2 == 0 {
// even
} else {
// odd
}An if statement is similar to a for statement in that it has a condition followed by a block. If statements also have an optional else part. If the condition evaluates to true then the block after the condition is run, otherwise either the block is skipped or if the else block is present that block is run.
If statements can also have else if parts:
if i % 2 == 0 {
// divisible by 2
} else if i % 3 == 0 {
// divisible by 3
} else if i % 4 == 0 {
// divisible by 4
}The conditions are checked top down and the first one to result in true will have its associated block executed. None of the other blocks will execute, even if their conditions also pass. (So for example the number 8 is divisible by both 4 and 2, but the // divisible by 4 block will never execute because the // divisible by 2 block is done first)
Putting it all together we have:
func main() {
for i := 1; i <= 10; i++ {
if i % 2 == 0 {
fmt.Println(i, "even")
} else {
fmt.Println(i, "odd")
}
}
}Let's walk through this program:
Create a variable i of type int and give it the value 1
Is i less than or equal to 10? Yes: jump to the block
Is the remainder of i ÷ 2 equal to 0? No: jump to the else block
Print i followed by odd
Increment i (the statement after the condition)
Is i less than or equal to 10? Yes: jump to the block
Is the remainder of i ÷ 2 equal to 0? Yes: jump to the if block
Print i followed by even
…
The remainder operator, while rarely seen outside of elementary school, turns out to be really useful when programming. You'll see it turn up everywhere from zebra striping tables to partitioning data sets.
Suppose we wanted to write a program that printed the English names for numbers. Using what we've learned so far we might start by doing this:
if i == 0 {
fmt.Println("Zero")
} else if i == 1 {
fmt.Println("One")
} else if i == 2 {
fmt.Println("Two")
} else if i == 3 {
fmt.Println("Three")
} else if i == 4 {
fmt.Println("Four")
} else if i == 5 {
fmt.Println("Five")
}Since writing a program in this way would be pretty tedious Go provides another statement to make this easier: the switch statement. We can rewrite our program to look like this:
switch i {
case 0: fmt.Println("Zero")
case 1: fmt.Println("One")
case 2: fmt.Println("Two")
case 3: fmt.Println("Three")
case 4: fmt.Println("Four")
case 5: fmt.Println("Five")
default: fmt.Println("Unknown Number")
}A switch statement starts with the keyword switch followed by an expression (in this case i) and then a series of cases. The value of the expression is compared to the expression following each case keyword. If they are equivalent then the statement(s) following the : is executed.
Like an if statement each case is checked top down and the first one to succeed is chosen. A switch also supports a default case which will happen if none of the cases matches the value. (Kind of like the else in an if statement)
These are the main control flow statements. Additional statements will be explored in later chapters.
What does the following program print:
i := 10
if i > 10 {
fmt.Println("Big")
} else {
fmt.Println("Small")
}Write a program that prints out all the numbers evenly divisible by 3 between 1 and 100. (3, 6, 9, etc.)
Write a program that prints the numbers from 1 to 100. But for multiples of three print "Fizz" instead of the number and for the multiples of five print "Buzz". For numbers which are multiples of both three and five print "FizzBuzz".
| ← Previous | Index | Next → |