Basic Control flow
In the previous chapter, we learned how to declare variables and constants. We also saw the different basic, builtin types that come with Go. In this chapter, we will see the basic control constructions, or how to reason about this data. But before that, let's talk about comments and semicolons.
You probably noticed in the example snippets given in previous chapters, some comments. Didn't you? Go has the same commenting conventions as in C++. That is:
- Single line comments: Everything from
//until the end of the line is a comment.
- bloc comments: Everything betwwen
*/is a comment.
If you've programmed with C, or C++, or Pascal, you might wonder why, in the previous examples, there weren't any semicolons. In fact, you don't need them in Go. Go automatically inserts semicolons on every line end that looks like the end of a statement.
And this makes the code a lot cleaner, and easy on the eyes.
The only place you will typically see semicolons is separating the clauses of for loops and the like; they are not necessary after every statement.
Note that you can use semicolons to separate several statements written on a single line.
The one surprise is that it's important to put the opening brace of a construct such as an if statement on the same line as the if; if you don't, there are situations that may not compile or may give the wrong result 
Ok let's begin, now.
The if statement
Perhaps the most well-known statement type in imperative programming. And it can be summarized like this: if condition met, do this, else do that.
In Go, you don't need parenthesis for the condition.
You can also have a leading initial short statement before the condition too.
You can combine multiple if/else statements.
The for statement
for statement is used to iterate and loop.
Its general syntax is:
expression3 are used for
assignements or function calls (
expression1 before starting the loop, and
expression3 at the end of every iteration) and
expression2 is used to
determine whether to continue or stop the iterations.
An example would be better than the previous paragraph, right? Here we go!
In the code above we initalize our variable
sum to 0. The
for loop by
is begun by initializing the variable
index to 0 (
for loop's body is executed (
sum += i) while the condition
index < 10 is true.
At the end of each iteration the
for loop will execute the
expression (eg. increments
You might guess that the output from the previous program would be:
And you would be correct! Because the sum is 0+1+2+3+4+5+6+7+8+9 which equals 45.
Is it possible to combine lines 5 and 6 into a single one, in the previous program? How?
expression3 are all optional.
This means you can omit, one, two or all of them in a
for loop. If you omit
expression3 it means they simply won't be executed. If
expression2 that'd mean that it is always true and that the loop
will iterate forever -- unless a
break statement is encountered.
Since these expressions may be omitted, you can have something like:
Which can be simplified by removing the semicolons:
Or when even expression2 is omitted also, we can have something like:
break and continue
break you can stop loops early. i.e. finish the loop even if the
condition expressed by
expression2 is still true.
The previous snippet says: loop from 10 to 0 printing the numbers (line 6); but if i<5 then break (stop) the loop! Hence, the program will print the numbers: 10, 9, 8, 7, 6, 5.
continue, on the other hand will just break the current iteration and
skips to the next one.
Here the program will print all the numbers from 10 down to 1, except 5! Because
on line 3, the condition
if index == 5 will be
will be executed and the
fmt.Println(index) (for index == 5) won't be run.
The switch statement
Sometimes, you'll need to write a complicated chain of
And the code becomes ugly and hard to read and maintain. The
statement, makes it look nicer and easier to read.
Go's switch is more flexible than its C equivalent, because the case expression need not to be constants or even integers.
The general form of a switch statement is
The type of
sExpr and the expressions
type should match. i.e. if
var is of type
int the cases expressions should
be of type
Of course, you can have as many cases you want.
Multiple match expressions can be used, each separated by commas in the case statement.
If there is no
sExpr at all, then by default it's bool and so should be
the cases expressions.
If more than one case statements match, then the first in lexical order is executed.
The default case is optional and can be anywhere within the switch block, not necessarily the last one.
Unlike certain other languages, each case block is independent and code does not "fall through" (each of the case code blocks are like independent if-else-if code blocks. There is a fallthrough statement that you can explicitly use to obtain fall through behavior if desired.)
Some switch examples:
In this snippet, we initialized
index to 10, but in practice, you should
index as a computed value (result of a function or some other
calculus before the switch statement)
Notice that in line 6, we grouped some expressions (2, 3, and 4) in a single case statement.
Now, in this example, we omitted
sExpr of the general form. So the cases
expressions should be of type bool. And so they are! (They're comparisons that
Can you tell why the
defaultcase on line 10 will never be reached?
In this example, the case on line 10 matches, but since there is
fallthrough, the code for
case 7: and so on will also be executed
(just like a C switch that doesn't use the