Golang for Experienced Developers - Part III
Tags: go, beginners, tutorial, programming
Published: 2021-10-03 15:14:54

### Hi, I'm back
This is the third part of Golang tutorial series, if you haven't checked out the first & second parts, do check it out [here](https://dev.to/livesamarthgupta/golang-for-experienced-developers-5bba).


## Control Constructs in Go
Go provides following statements for controlling the program flow:

### If statement

###### Syntax:
```
// Regular if
if condition {
    ...
}

// Initialised if
if initialisation; condition {
    ...
}

// if-else
if condition {
    ...
} else {
    ...
}

if condition1 {
    ...
} else if condition2 {
    ...
} else {
    ...
}
```

###### Points to remember:
* Go provides two syntaxes for `if` statements, one with initialisation & one without initialisation.
* Braces are mandatory, even for one line.
* The `{` (opening brace) after the `if` and `else` must be on the same line.
* The `else if` and `else` must be on same line as `}` (closing brace).
* Can use parentheses for composite expressions with &&, ||, !
* The `;` after `initialisation` is required.
* Use local assignments (`:=`) for `initialisation` in initialised if statements.
* Scope of initialisation variable is known only within `if` statement.
* Can also invoke functions to initialise variable in the initialised if statements.

###### Example:
```
package main
import ("fmt"; "runtime")

func main() {
    if platform := runtime.GOOS; platform == "linux" { // fetch os info 
      fmt.Println("linux platform")
    } else if platform  == "darwin" {
      fmt.Println("darwin platform")
    } else {
      fmt.Println("windows platform")
    }
}
```
---

### Switch Statement

###### Syntax:
```
// Regular switch
switch variable {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

// Initialised switch 
switch initialisation; variable {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

// Tag-less switch
switch {
    case boolexpr1:
        ...
    case boolexp2:
        ...
    default:
        ...
}
```

###### Points to remember:
* Go provides three syntaxes for `switch` statement.
* The `{` (opening brace) must be on the same line as the `switch`
* `variable` can be any type.
* `val1`, `val2` must be of the same type.
* More than one value may appear in a case.
* Breaks from each case are implicit.
* Use keyword `fallthrough` to combine `case` conditions.
* Braces (`{` and `}`) are allowed in case for multiple statements.
* Use keyword `default` to handle conditions that match no `case`
* Keyword `default` may be placed anywhere in switch.
* In tag-less switch statements, `case` statements must evaluate to boolean expressions.

###### Example:
```
package main
import ("fmt"; "runtime", "os")

func main() {
    switch platform := runtime.GOOS; platform {
        case "linux", "darwin", "windows":   // multiple cases
            fmt.Println("Known OS")
        default:
            fmt.Println("Unknown OS")
     }

    arg := os.Args[1]  // fetch command line argument
    num, _ := strconv.ParseFloat(arg, 64) // string to float64
    var val float64
    switch {
         case num < 0:
             num = -num
             fallthrough   // fallthrough to second case
         case num > 0:
             val = math.Sqrt(num)
         case num == 0:
             val = 0;
    }
    fmt.Println(val)    
}
```
---

### For statement

###### Syntax:
```
// Counter controlled loop
for initialisation; condition; update {
    ...
}

// Condition controlled loop
for condition {
    ...
}

// Range controlled loop
for index, value := range collection {
    ... 
}
for index := range collection {
    ...
}
```

###### Points to remember:
* Go provides three syntaxes for `for` statement.
* No while or do while statements.
* Braces are mandatory, even for one line.
* Opening brace `{` must be on the same line as `for`
* Surrounding parenthesis after `for` are not allowed.
* May assign more than one counter in initialise with commas
* Omitting `condition` in a condition controlled loop results in an infinite loop.
* In range controlled loops, `collection` is a sequence of items (string, array, map).
* `index` is the integer index at each iteration in the loop.
* `value` is the item in the collection at each iteration in the loop.

###### Example:
```
package "main"
import "fmt"
import "os"

func main() {
    nargs := len(os.Args)
    // counter controlled
    for i := 1; i < nargs; i++ {
        fmt.Printf("%s ", os.Args[i])
    }
    
    args1 := os.Args[1:]
    // condition controlled
    for len(args) > 0 {
        fmt.Printf("%s ", args1[0])
        args1 = args1[1:]  // shift left
    }

    args2 := os.Args[1:]
    // range controlled
    for i, arg := range args {
        fmt.Printf("%d %s\n", i, arg)
    }
}
```
---

### Break & Continue Statement

###### Break:
* Used inside a `for`, `switch`, or `select` statement.
* Breaks out of innermost loop in multiple `for` statements.
* Can be used with labels.

###### Continue:
* Can only be used in `for` statement.
* Continues with the next iteration of innermost loop.
* Skips remaining body of loop.
* Can be used with labels.

###### Example:
```
package main
import "fmt"
func main() {
    for i := 1; i < 25; i++ {
        if i % 2 != 0 { continue }
        if i > 20 { break }
        fmt.Printf("%d ", i)
    }
}
```
---

This concludes the third part of the series. In next tutorial we'll cover `functions` and more, till then, Aloha.

Reach out to me [here](https://guptasamarth.netlify.app/)