Go -- Branching and Looping

Branching

Two types ...

• if, else and else if statements
• switch statement

If ... else syntax

if a%2 == 0 {
    // do something
} else if a == 3 {
    // do something
} else {
    // do something
}

With some inline initialisation ...

if err := validate(something); err != nil {
    // do something
}

There are some rules for above initialisation version.

• The initialised variable (err above) goes out of scope once the if block exits.
• Only the short hand assignment ( := ) is allowed. var keyword is not allowed.
• Only some simple assignments are allowed.

Switch statement

Python does not have one. Java has and JavaScript also has.

Go has two types of switch statements .... expression switch and type switch.

Expression switch

switch <some initialisation>; <switch_expresion> {
    case expression1:
        // statements. See there are no braces here.
    case expression2, expression3:
        // statements
    default:
        // statements
}

• The initialisation is same as if. It's scope is limited to the switch statement. It is optional.
• The is also optional. If it is not provided and initialisation is provided, then the syntax becomes like switch <some initialisation>; {. If both are omitted, then the switch expression evaluates to true and it looks like switch {.
• When the is given, the value of the is checked against the case expressions for equality. If multiple expressions are given in the same case, then one of them must be equal to the value of for the case to execute.
• When the is not given, then each case expression is evaluated for true or false.
• At least one case block (other than the default) is compulsory.
• In other languages, the execution falls (goes) through all the subsequent cases after a match is found, unless we use a break statement. This is exactly opposite in Go. Here, the when a match is found, only that case's statements are executed and the switch exits. If we want the execution to fall through the subsequent cases as well (like other languages), then we must add a fallthrough statement at the end of the statements of the matching case and all the required subsequent cases.
• If no match is found, and if a default case is provided, then it will be executed. It acts like else of an if statement.

Type switch

pass

Looping

Go supports only one type of loop construct ... for. But it is flexible enough.

It can take three forms broadly.

• Conventional C-type : for <initialisation>; <condition>; <post_statement> {
• Looping directly over Iterables : for <condition> {. This is the only way Python supports.
• Looping over unordered collections with the help of range keyword.

break and continue are available in Go.

Use of range keyword :

range iterates over a variety of data structures. The following example from ______ is a very good example.

package main

import "fmt"

func main() {

    nums := []int{2, 3, 4}

    // `range` on arrays and slices provides both the
    // index and value for each entry.
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    // we can ignore any one of the variables with a '_'
    for _, num := range nums {
        fmt.Println(num)
    }

    // `range` on map iterates over key/value pairs.
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

    // `range` can also iterate over just the keys of a map.
    // Strange. There is no change on the use of 'range' keyword on the
    // right hand side of the assignment. It's only that we are
    // now assigning to one variable on the left side.
    for k := range kvs {
        fmt.Println("key:", k)
    }

    // `range` on strings iterates over Unicode code
    // points. The first value is the starting byte index
    // of the `rune` and the second the `rune` itself.
    // This very important. Conventional c-type looping over the length of
    // a string, gives the individual bytes, not the runes.
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

• range on slices and arrays works somewhat like the enumerate() function (from 'collections' module) in Python.
• Just like in Python, we can ignore some return values (in assignments) with underscore _.
• range on maps is strange. If we assign to two variables, then we get both the key value pair. If we assign to one variable only, then we get only the key. I don't understand why the second way is made available when we can ignore any of the returned variables (key or value) with the underscore _ assignment. Like for key, _ := range some_map { . But, it seems Go does not recommend that way. In fact, the gofmt tool automatically converts such statements to single assignments.
• range on strings also is noteworthy. Given that a string is just a sequence of bytes, range does not just simply iterates over the bytes. Rather, it returns unicode code points (or rune type values). This is always the preferred way for looping over the characters of a string, in that case.