{"id":162,"date":"2026-07-07T20:29:05","date_gmt":"2026-07-07T20:29:05","guid":{"rendered":"https:\/\/kindsonthegenius.com\/go\/2026\/07\/07\/05-go-control-flow\/"},"modified":"2026-07-08T19:18:43","modified_gmt":"2026-07-08T19:18:43","slug":"05-go-control-flow","status":"publish","type":"post","link":"https:\/\/kindsonthegenius.com\/go\/05-go-control-flow\/","title":{"rendered":"Go Control Flow \u2013 if, else, switch, and for Loops"},"content":{"rendered":"

<\/p>\n

\n

Updated July 2, 2026.<\/strong> Refreshed for Go 1.22+ and current SEO best practices.<\/p>\n<\/div>\n

In this lesson we cover Go control flow<\/strong> \u2014 how programs make decisions and repeat work. You will learn go if else for loop<\/strong> patterns that appear in every real Go codebase: branching with if<\/code> and switch<\/code>, and iterating with for<\/code> in its classic, while-style, and range<\/code> forms. If you completed Lesson 4 \u2013 Variables and Types<\/a>, you already know how to store data; now we act on it.<\/p>\n

Prerequisites:<\/strong> Lessons 1\u20134 of this series, especially Variables and Types<\/a> and Basic Syntax<\/a>. Estimated time:<\/strong> 40\u201350 minutes.<\/p>\n

1. if and else Statements<\/h4>\n

The if<\/code> statement runs a block when a condition is true. Go requires parentheses around the condition \u2014 unlike C \u2014 but does not<\/strong> require parentheses around the condition expression itself:<\/p>\n

package main\n\nimport \"fmt\"\n\nfunc main() {\n\tscore := 85\n\n\tif score >= 90 {\n\t\tfmt.Println(\"Grade: A\")\n\t} else if score >= 80 {\n\t\tfmt.Println(\"Grade: B\")\n\t} else {\n\t\tfmt.Println(\"Grade: C or below\")\n\t}\n}\n<\/code><\/pre>\n
Key rules: the opening brace {<\/code> must be on the same line as if<\/code> (Go enforces this). Conditions must be boolean expressions \u2014 Go will not treat 0<\/code> or \"\"<\/code> as false the way some languages do. This strictness prevents subtle bugs and makes intent obvious when you read code.<\/p>\n
2. if with a Short Statement<\/h4>\n
Go allows a short statement before the condition, separated by a semicolon. The variable declared in that statement is scoped only to the if<\/code> block (and its else<\/code> branches):<\/p>\n
package main\n\nimport (\n\t\"fmt\"\n\t\"math\"\n)\n\nfunc main() {\n\tx := 16.0\n\n\tif root := math.Sqrt(x); root > 3 {\n\t\tfmt.Printf(\"Square root %.2f is greater than 3\\n\", root)\n\t} else {\n\t\tfmt.Printf(\"Square root %.2f is 3 or less\\n\", root)\n\t}\n\t\/\/ root is not visible here\n}\n<\/code><\/pre>\n
This pattern is idiomatic when you need a temporary value only for the decision \u2014 for example, parsing input or calling a function that returns a result and an error. You will see if err := doSomething(); err != nil { ... }<\/code> throughout Go code; we explore that error-handling style more when we cover functions.<\/p>\n
3. switch Statements<\/h4>\n
switch<\/code> compares a value against multiple cases. Unlike C, Go cases do not fall through unless you use fallthrough<\/code>:<\/p>\n
package main\n\nimport \"fmt\"\n\nfunc main() {\n\tday := \"Wednesday\"\n\n\tswitch day {\n\tcase \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\":\n\t\tfmt.Println(\"Weekday\")\n\tcase \"Saturday\", \"Sunday\":\n\t\tfmt.Println(\"Weekend\")\n\tdefault:\n\t\tfmt.Println(\"Unknown day\")\n\t}\n}\n<\/code><\/pre>\n
Go also supports switch without a tag<\/strong> \u2014 each case is a boolean expression, useful as a cleaner alternative to long if else<\/code> chains:<\/p>\n
score := 72\n\nswitch {\ncase score >= 90:\n\tfmt.Println(\"Excellent\")\ncase score >= 70:\n\tfmt.Println(\"Good\")\ndefault:\n\tfmt.Println(\"Keep practicing\")\n}\n<\/code><\/pre>\n
Switch cases can use constants, strings, integers, and more. Because there is no automatic fall-through, you rarely need break<\/code> \u2014 one less source of errors compared to C-style switches.<\/p>\n
4. Classic for Loop<\/h4>\n
Go has one loop keyword: for<\/code>. The classic three-part form mirrors C:<\/p>\n
package main\n\nimport \"fmt\"\n\nfunc main() {\n\tsum := 0\n\tfor i := 1; i <= 5; i++ {\n\t\tsum += i\n\t}\n\tfmt.Println(\"Sum 1..5 =\", sum) \/\/ 15\n}\n<\/code><\/pre>\n
The init statement, condition, and post statement are all optional. An infinite loop is written as for { }<\/code> \u2014 use break<\/code> inside to exit. Unlike Python's for i in range(n)<\/code>, Go's C-style loop gives you full control over the counter variable and step size.<\/p>\n
5. While-Style for Loop<\/h4>\n
Go has no while<\/code> keyword. A condition-only for<\/code> loop acts like while<\/code> in other languages:<\/p>\n
package main\n\nimport \"fmt\"\n\nfunc main() {\n\tn := 1\n\tfor n < 100 {\n\t\tn *= 2\n\t}\n\tfmt.Println(\"First power of 2 >= 100:\", n) \/\/ 128\n}\n<\/code><\/pre>\n
This form is common when you do not know how many iterations you need in advance \u2014 reading from a buffer, retrying a network call, or processing until a sentinel value appears. Combine with break<\/code> and continue<\/code> to skip the rest of an iteration or exit the loop early.<\/p>\n
6. for range Loop<\/h4>\n
The range<\/code> keyword iterates over slices, arrays, strings, maps, and channels. For a slice or array, you get an index and a copy of each element:<\/p>\n
package main\n\nimport \"fmt\"\n\nfunc main() {\n\tlanguages := []string{\"Go\", \"Python\", \"Rust\"}\n\n\tfor index, lang := range languages {\n\t\tfmt.Printf(\"%d: %s\\n\", index, lang)\n\t}\n\n\t\/\/ Index only \u2014 discard value with _\n\tfor i := range languages {\n\t\tfmt.Println(i, languages[i])\n\t}\n}\n<\/code><\/pre>\n
When ranging over a string, the index is a byte offset and the value is a rune<\/code> (Unicode code point). For maps, range<\/code> yields key-value pairs in random order. We cover slices and maps in depth in later lessons; for now, treat range<\/code> as the idiomatic way to visit every item in a collection.<\/p>\n
7. Choosing the Right Construct<\/h4>\n
Use this quick reference when deciding which control structure fits:<\/p>\n\n\n\n\n\n\n\n\n\n\n
Goal<\/th>\nConstruct<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
Two-way branch<\/td>\nif else<\/code><\/td>\nif x > 0 { ... } else { ... }<\/code><\/td>\n<\/tr>\n
Scoped temp before test<\/td>\nif<\/code> short statement<\/td>\nif v := f(); v > 0 { ... }<\/code><\/td>\n<\/tr>\n
Many discrete values<\/td>\nswitch<\/code><\/td>\nswitch day { case \"Mon\": ... }<\/code><\/td>\n<\/tr>\n
Counted iteration<\/td>\nClassic for<\/code><\/td>\nfor i := 0; i < n; i++ { ... }<\/code><\/td>\n<\/tr>\n
Condition-driven loop<\/td>\nWhile-style for<\/code><\/td>\nfor condition { ... }<\/code><\/td>\n<\/tr>\n
Collection iteration<\/td>\nfor range<\/code><\/td>\nfor i, v := range items { ... }<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Go favors simplicity: one loop keyword, explicit conditions, and no hidden truthiness. If you learned control flow in Python<\/a>, notice that Go's for range<\/code> is the closest equivalent to for item in collection<\/code>, while counted loops use the three-part for<\/code> form instead of range(n)<\/code>.<\/p>\n
8. Next Steps<\/h4>\n
You now understand go if else for loop<\/strong> control flow: branching, switch, and every form of the for<\/code> loop. In the next lesson we cover functions<\/strong> \u2014 how to organize code into reusable blocks with parameters, return values, and defer<\/code>.<\/p>\n
Continue the series: Lesson 4 \u2013 Variables and Types<\/a> \u00b7 Lesson 6 \u2013 Functions<\/a><\/p>\n
Browse all tutorials: Content Directory<\/a> \u00b7 Go Programming Hub<\/a><\/p>\n
Frequently Asked Questions<\/h4>\n
Does Go have a while loop?<\/strong>
\nNo. Use for condition { }<\/code> without init or post statements. It behaves exactly like a while<\/code> loop in other languages.<\/p>\n
Do switch cases fall through in Go?<\/strong>
\nNo, by default. Each case runs only its own block and then exits the switch. Use fallthrough<\/code> explicitly if you truly need C-style fall-through \u2014 which is rare.<\/p>\n
Can I modify the loop variable in a range loop?<\/strong>
\nThe range value is a copy<\/em> of each element. Changing it does not update the underlying slice. Use the index form for i := range s { s[i] = ... }<\/code> to modify slice elements.<\/p>\n
<\/p>\n