4. Maps and Control Structures

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Previous Chapter

3. Arrays, Slices, and Iteration

4. Maps and Control Structures

This chapter covers the basics of maps and control structures. We explain how maps are a powerful tool for storing key-value pairs. This chapter also covers control structures such as if and switch statements.

Maps

Maps are a powerful built-in data structure that associates keys and values. A map is an unordered set of values indexed by a unique key. Map keys and values can be set and retrieved using the [] syntax. In Listing 4.1, we create a new map, map[string]string{}, and assign it to the users variable. To assign a value, we can access the key using the users[<key>] syntax. In this case, we are accessing the key, Janis, for assignment. To retrieve the Janis key from the map, we can reverse the process. If we move the users[<key>] syntax to the right of the assignment operator, we are now accessing the value of the key for reading.

Listing 4.1 Setting and Retrieving Map Values

Click here to view code image

func main() {
    // create a map of strings to strings
    users := map[string]string{}

    // add a new key/value pair
    users["Janis"] = "[email protected]"

    // ask for a value using the key
    email := users["Janis"]

    // print the value
    fmt.Println(email)
}

$ go run .

[email protected]

Go Version: go1.19

Length and Capacity

You can use built-in len¹ function to find the length (the number of keys) of a map. In Listing 4.2, we assigning 4 values into the users map. We then use the len function to retrieve the number of keys in the map. As shown in the output in Listing 4.2, the len function is correctly reporting the length of the users map as 4.

1. https://pkg.go.dev/builtin#len

Listing 4.2 Using the len Function to Find the Length of a Map

Click here to view code image

func main() {
    users := map[string]string{}

    users["Kurt"] = "[email protected]"
    users["Janis"] = "[email protected]"
    users["Jimi"] = "[email protected]"
    users["Amy"] = "[email protected]"

    fmt.Println("Map length:", len(users))
}

$ go run .

Map length: 4

Go Version: go1.19

Theoretically, maps are able to hold an infinite number of keys. Because maps have unlimited capacity, the built-in cap function cannot be used to find the capacity of a map. Listing 4.3 shows that trying to call the cap function with a map results in a compilation error informing us that a map is an invalid argument for the cap function.

Listing 4.3 Maps Have an “Unlimited” Capacity

Click here to view code image

func main() {
    users := map[string]string{}

    users["Kurt"] = "[email protected]"
    users["Janis"] = "[email protected]"
    users["Jimi"] = "[email protected]"
    users["Amy"] = "[email protected]"

    fmt.Println("Map capacity:", cap(users))
}

$ go run .

# demo
./main.go:14:35: invalid argument: users (variable of type
map[string]string) for cap

Go Version: go1.19

Initializing Maps

You can initialize maps in a couple of ways. The first, and recommended, way is to initialize the map at the same time as declaring the variable, as in Listing 4.4. This also allows for initializing the map with an initial set of keys and values.

Listing 4.4 Initializing a Map with a Short Syntax

Click here to view code image

You also can use the make² function to create new maps, as in Listing 4.5. Unlike slices and arrays, maps cannot be initialized with a length and capacity. Older code may use the make function; however, it is considered nonidiomatic in most circumstances to use the make function for map initialization.

2. https://pkg.go.dev/builtin#make

Listing 4.5 Initializing a Map with the make Function

Click here to view code image

Uninitialized Maps

If you don’t initialize a map and try to access the values, you will receive a runtime panic, as shown in Listing 4.6.

Listing 4.6 Accessing an Uninitialized Map

Click here to view code image

var users map[string]string
users["[email protected]"] = "Kurt"

$ go run .

map[[email protected]:Janis [email protected]:Jimi
[email protected]:Kurt]
map[[email protected]:Janis [email protected]:Jimi
[email protected]:Kurt]

panic: assignment to entry in nil map

goroutine 1 [running]:
main.bad()
        ./main.go:41 +0x38
main.main()
        ./main.go:8 +0x28
exit status 2

Go Version: go1.19

Map Keys

Map keys must be comparable, which means the Go runtime can check the equality of the key in the map with the key being given. In Go, not all types are comparable. Basic data types, such as string, []byte, and int, are the most-used key types. All are comparable and provide enough type variation to handle most use cases.

Complex and noncomparable types—such as functions (Listing 4.7), maps, or slices—cannot be used as key types in maps. Use of noncomparable types causes a compile time error.

Listing 4.7 Using a Noncomparable Type as a Map Key

Click here to view code image

Structs as Keys

A struct whose fields are all simple comparable types can be used as a key type for a map. This can be useful for creating tuple-style keys. In Listing 4.8, because the Simple struct is composed of two fields, ID and Name, both of which are comparable types, the Simple struct can be used as the key type for a map.

Listing 4.8 Using a Struct with Simple Fields as a Map Key

Click here to view code image

// Simple contains only comparable fields
// and can be used as a key type for a map.
type Simple struct {
    ID   int
    Name string
}

func main() {

    // create a map of Simple keys
    // to string values
    simple := map[Simple]string{}

    // create a new Simple key
    sk := Simple{ID: 1, Name: "Kurt"}
    // add a new key/value pair
    simple[sk] = "[email protected]"

    // print the simple map
    fmt.Println(simple)
}

$ go run .

map[{1 Kurt}:[email protected]]

Go Version: go1.19

Structs that contain noncomparable fields, however, cannot be used as the key type for a map. Trying to do so causes a compilation error. In Listing 4.9, the Complex struct type is composed of two fields: Data and Fn. Both of these fields are complex noncomparable types. The Fn field, for example, is a function, and functions cannot be compared.

Listing 4.9 Using a Struct with Noncomparable Fields as a Map Key

Click here to view code image

// Complex contains non-comparable fields
// and cannot be used as a key type for a map.
type Complex struct {
    Data map[string]string
    Fn   func() error
}

func main() {

    // create a map of Complex keys
    // to string values
    complex := map[Complex]string{}

    // print the complex map
    fmt.Println(complex)
}

$ go run .

# demo
./main.go:19:17: invalid map key type Complex

Go Version: go1.19

Iterating Maps

Maps can be iterated over using the range keyword, in much the same way that arrays and slices can. The range keyword, in the case of maps, returns the key and the value for each entry in the map. In Listing 4.10, using the range keyword to iterate over the users map, we are given a single key/value pair, which are assigned to the key and value variables.

Listing 4.10 Iterating over a Map

Click here to view code image

func main() {
    users := map[string]string{
        "Kurt":  "[email protected]",
        "Janis": "[email protected]",
        "Jimi":  "[email protected]",
        "Amy":   "[email protected]",
    }

    // iterate over the map using a for loop
    // retrieve the key and value as variables
    for key, value := range users {
        fmt.Printf("%s <%s>
", key, value)
    }
}

$ go run .

Kurt <[email protected]>
Janis <[email protected]>
Jimi <[email protected]>
Amy <[email protected]>

Go Version: go1.19

Range returns the key and the value of each item in the map. If only the key for each loop is needed, and not the value, using only a single variable in the for loop with range returns only the key in the map. In Listing 4.11, instead of asking for both the key and value for each iteration of the map, we just ask for the key. We can then use that key to access the value from the map users[key].

Listing 4.11 Iterating over a Map with Only the Key

Click here to view code image

func main() {
    users := map[string]string{
        "Kurt":  "[email protected]",
        "Janis": "[email protected]",
        "Jimi":  "[email protected]",
        "Amy":   "[email protected]",
    }

    // iterate over the map using a for loop
    // retrieve the key as a variable
    for key := range users {

        // retrieve the value from the map
        // using the key
        fmt.Printf("%s <%s>
", key, users[key])
    }
}

$ go run .

Kurt <[email protected]>
Janis <[email protected]>
Jimi <[email protected]>
Amy <[email protected]>

Go Version: go1.19

Deleting Keys from a Map

You can use the built-in delete³ function, Listing 4.12, to remove a key, and its value, from a map.

3. https://pkg.go.dev/builtin#delete

Listing 4.12 The delete Function

Click here to view code image

$ go doc builtin.delete

package builtin // import "builtin"

func delete(m map[Type]Type1, key Type)
    The delete built-in function deletes the element with the specified
    key (m[key]) from the map. If m is nil or there is no such
    element, delete is a no-op.

Go Version: go1.19

Only one key at a time can be deleted from a map. In Listing 4.13, we call the delete function passing in the users map and the key Kurt. The result, when printed, is a map that no longer contains the Kurt key.

Listing 4.13 Deleting a Key from a Map

Click here to view code image

func main() {
    users := map[string]string{
        "Kurt":  "[email protected]",
        "Janis": "[email protected]",
        "Jimi":  "[email protected]",
        "Amy":   "[email protected]",
    }

    // delete the "Kurt" entry
    delete(users, "Kurt")

    // print the map
    fmt.Println(users)
}

$ go run .

map[Amy:[email protected] Janis:[email protected]
Jimi:[email protected]]

Go Version: go1.19

If the key is not present in the map, the delete function is a no-op, and the map will not be modified. In Listing 4.14, trying to delete a nonexistent key, Unknown, from the users map neither returns an error nor raises a panic. There is no indication as to the success or failure of calling the delete function.

Listing 4.14 Deleting a Key from a Map That Is Not Present

Click here to view code image

func main() {
    users := map[string]string{
        "Kurt":  "[email protected]",
        "Janis": "[email protected]",
        "Jimi":  "[email protected]",
        "Amy":   "[email protected]",
    }

    // delete the "Unknown" entry
    delete(users, "Unknown")

    // print the map
    fmt.Println(users)
}

$ go run .

map[Amy:[email protected] Janis:[email protected]
Jimi:[email protected] Kurt:[email protected]]

Go Version: go1.19

Nonexistent Map Keys

When asking for a key from a map that doesn’t exist, Go returns the zero of the map’s value type. This can often lead to bugs in code.

In Listing 4.15, you see that even if you don’t get an error, you still have a bug because you didn’t check for the existence of the value.

Listing 4.15 Getting a Nonexistent Map Key

Click here to view code image

func main() {
    data := map[int]string{}
    data[1] = "Hello, World"

    value := data[10]

    // Because of the way Zero values in Go work,
    // we still get an 'zero' value representation of the struct
    // which is certainly a bug in production
    fmt.Printf("%q", value)
}

$ go run .

""

Go Version: go1.19

Checking Map Key Existence

Maps in Go return an optional second boolean argument that tells you if the key exists in the map. Checking for the existence of the key in your code can help you avoid bugs caused by nonexistent keys.

In Listing 4.16, we ask for the optional second boolean argument when retrieving a value from a map. We then use that boolean, ok, to handle the case where the key is not present in the map.

Listing 4.16 Checking for the Existence of a Key in a Map

Click here to view code image

func main() {
    users := map[string]string{
        "Kurt":  "[email protected]",
        "Janis": "[email protected]",
        "Jimi":  "[email protected]",
        "Amy":   "[email protected]",
    }
    key := "Kurt"

    email, ok := users[key]
    if !ok {
        fmt.Printf("Key not found: %q
", key)
        os.Exit(1)
    }

    fmt.Printf("Found key %q: %q", key, email)

}

$ go run .

Found key "Kurt": "[email protected]"

Go Version: go1.19

Exploiting Zero Value

There may be times when the zero value is OK. Consider Listing 4.17 and the task of counting the occurrences of words in a string. To store the count of each word, you can use a map with the key type string and the value type int.

When asking this map for a key that doesn’t exist, the zero value of the map’s value type is returned. The zero value of an int is 0, which is a valid starting point for counting a word’s occurrences.

Listing 4.17 Counting the Occurrences of Words in a String

Click here to view code image

func main() {
    counts := map[string]int{}

    sentence := "The quick brown fox jumps over the lazy dog"

    words := strings.Fields(strings.ToLower(sentence))

    for _, w := range words {
        // if the word is already in the map, increment it
        // otherwise, set it to 1 and add it to the map
        counts[w] = counts[w] + 1
    }
    fmt.Println(counts)
}

$ go run .

map[brown:1 dog:1 fox:1 jumps:1 lazy:1 over:1 quick:1 the:2]

Go Version: go1.19

Integers in Go can be incremented and decremented in place, using the ++ or -- operators, respectively. This means our code could be simplified because the act of incrementing the zero value of a missing map key causes the key/value pair to be added to the map. For example, in Listing 4.18, we are incrementing a map key’s value in-place using the ++ operator.

Listing 4.18 Using ++ to Increment a Map Value in Place

Click here to view code image

Testing Presence Only

When retrieving a value from a map, you can use the second, optional, boolean argument to test whether the key exists in the map. To do this, however, you must also capture the value. There may be times when the value is not needed. In this case, you can use the _ to discard the value. For example, in Listing 4.19, when asking for the key foo from the map, we can discard the value by using the underscore (_) operator and only retain the second boolean value to the exists variable.

Listing 4.19 Testing the Presence of a Key in a Map

Click here to view code image

func main() {
    words := map[string]int{
        "brown": 1,
        "dog":   1,
        "fox":   1,
        "jumps": 1,
        "lazy":  1,
        "over":  1,
        "quick": 1,
        "the":   2,
    }

    // discard the value using '_'
    // keep only the existence boolean
    _, exists := words["foo"]

    fmt.Println(exists)
}

$ go run .

false

Go Version: go1.19

Maps and Complex Values

Storing complex values, such as a struct, in a map is a very common practice. However, updating those complex values is not as straightforward as updating a simple value, like an int.

It may seem intuitive to simply assign a new value to a struct via a map lookup, like we did with an int in Listing 4.17. However, this is not the case. In Listing 4.20, you see that trying to update a struct in place causes a compilation error.

Listing 4.20 Compilation Error Trying to Update a Struct in a Map

Click here to view code image

type User struct {
    ID   int
    Name string
}

func main() {

    // create a map of users
    data := map[int]User{}

    // create a new user
    user := User{ID: 1, Name: "Kurt"}

    // add the user to the map
    data[1] = user

    // update the user in the map
    data[1].Name = "Janis"

    fmt.Printf("%+v", data)
}

$ go run .

# demo
./main.go:23:2: cannot assign to struct field data[1].Name in map

Go Version: go1.19

Copy on Insert

When inserting a value into a map, the value is copied, Listing 4.21. This means that changes made to the original value after insertion aren’t reflected in the value stored in the map.

Listing 4.21 Values Inserted into a Map Are Copied

Click here to view code image

type User struct {
    ID   int
    Name string
}

func main() {

    // create a map of users
    data := map[int]User{}

    // create a new user
    user := User{ID: 1, Name: "Kurt"}

    // add the user to the map
    data[1] = user

    // update the user
    user.Name = "Janis"

    fmt.Printf("User: %+v
", user)
    fmt.Printf("Map: %+v
", data)
}

$ go run .

User: {ID:1 Name:Janis}
Map: map[1:{ID:1 Name:Kurt}]

Go Version: go1.19

Updating Complex Map Values

When updating a complex value in a map, Listing 4.22, that value must first be retrieved from the map. Once retrieved, the value can be updated. After the changes have been made, the value needs to be reinserted into the map for the changes to take effect.

Listing 4.22 Updating Complex Values in a Map

Click here to view code image

type User struct {
    ID   int
    Name string

}

func main() {

    // create a map of users
    data := map[int]User{}

    // create a new user
    user1 := User{ID: 1, Name: "Kurt"}

    // add the user to the map
    data[1] = user1

    // retrieve the user from the map
    user2 := data[1]

    // update the user
    user2.Name = "Janis"

    // re-insert the user into the map
    data[1] = user2

    fmt.Printf("%+v", data)
}

$ go run .

map[1:{ID:1 Name:Janis}]

Go Version: go1.19

Listing Keys in a Map

Go does not provide a way to get just a list of keys or values from a map. To build a list of keys or values, Listing 4.23, you must iterate over the map and save the keys or values to a slice or array.

Listing 4.23 Listing Keys from a Map

Click here to view code image

func main() {

    // create a map of months
    months := map[int]string{
        1:  "January",
        2:  "February",
        3:  "March",
        4:  "April",
        5:  "May",
        6:  "June",
        7:  "July",
        8:  "August",
        9:  "September",
        10: "October",
        11: "November",
        12: "December",
    }

    // create a slice to hold the keys
    // set its length to 0 to start with
    // and its capacity to the length
    // of the map
    keys := make([]int, 0, len(months))

    // loop through the map
    for k := range months {

        // append the key to the slice
        keys = append(keys, k)
    }

    fmt.Printf("keys: %+v
", keys)
}

$ go run .

keys: [2 3 4 6 7 8 10 1 5 9 11 12]

Go Version: go1.19

In Go, maps are not ordered and there are no built-in methods for sorting maps. When iterating over a map, like in Listing 4.23, the order of the keys is not guaranteed.

Sorting Keys

To sort a map, you must first get the keys from the map, sort the keys, and then use the sorted keys to retrieve the values from the map. The sort⁴ package, Listing 4.24, provides a number of functions and interfaces for sorting collection types.

4. https://pkg.go.dev/sort

Listing 4.24 The sort Package

Click here to view code image

$ go doc sort

package sort // import "sort"

Package sort provides primitives for sorting slices and
user-defined collections.

func Float64s(x []float64)
func Float64sAreSorted(x []float64) bool
func Ints(x []int)
func IntsAreSorted(x []int) bool
func IsSorted(data Interface) bool
func Search(n int, f func(int) bool) int
func SearchFloat64s(a []float64, x float64) int
func SearchInts(a []int, x int) int
func SearchStrings(a []string, x string) int
func Slice(x any, less func(i, j int) bool)
func SliceIsSorted(x any, less func(i, j int) bool) bool
func SliceStable(x any, less func(i, j int) bool)
func Sort(data Interface)
func Stable(data Interface)
func Strings(x []string)
func StringsAreSorted(x []string) bool
type Float64Slice []float64
type IntSlice []int
type Interface interface{ ... }
    func Reverse(data Interface) Interface
type StringSlice []string

Go Version: go1.19

In Listing 4.25, after iterating over the map and building a slice of keys, we can sort those keys in place using the sort.Ints⁵ function. With a sorted list of keys, we can then iterate over the keys and retrieve the values from the map. The result, as shown in Listing 4.25, is a sorted list of values.

5. https://pkg.go.dev/sort#Ints

Listing 4.25 Sorting Keys and Retrieving Values from a Map

Click here to view code image

func main() {

    // create a map of months
    months := map[int]string{
        1:  "January",
        2:  "February",
        3:  "March",
        4:  "April",
        5:  "May",
        6:  "June",
        7:  "July",
        8:  "August",
        9:  "September",
        10: "October",
        11: "November",
        12: "December",
    }

    // create a slice to hold the keys
    // set its length to 0 to start with
    // and its capacity to the length
    // of the map
    keys := make([]int, 0, len(months))

    // loop through the map
    for k := range months {

        // append the key to the slice
        keys = append(keys, k)
    }

    // sort the keys
    sort.Ints(keys)

    // loop through the keys
    // and print the key/value pairs
    for _, k := range keys {
        fmt.Printf("%02d: %s
", k, months[k])
    }
}

$ go run .

01: January
02: February
03: March
04: April
05: May
06: June
07: July
08: August
09: September
10: October
11: November
12: December

Go Version: go1.19

If Statements

If statements are the core way that most programming languages use to make logic decisions. The if statement in Go is like most other languages, with a few extra syntax options.

In Listing 4.26, we use an equality comparison, the == operator, to determine whether the greet variable is equal to true. If it is, we print the hello string.

Listing 4.26 A Basic Boolean Logic Check

Click here to view code image

Due to the way that Go interprets the expression, you can use anything that evaluates to true. Listing 4.26 can be rewritten to remove the comparison against true. Listing 4.27 functions identically to Listing 4.26, but it does so by just using the single variable greet that evaluates to true or false.

Listing 4.27 A Basic if Statement

Click here to view code image

The `else` Statement

We can also make use of the else statement, Listing 4.28. This allows us to program for both the true and false state of our expression.

Listing 4.28 An if Statement with an else Statement

Click here to view code image

Although Listing 4.28 is valid code, in Go, it is considered best practice to avoid using the else statement whenever possible. A common use case is to use what is referred to as an “early return.” Listing 4.29 is functionally equivalent to Listing 4.28, but it uses an early return to avoid using the else keyword. The typical result is clearer code.

Listing 4.29 An if Statement with an Early Return

Click here to view code image

The `else if` Statement

When necessary, you can make use of the else if syntax, Listing 4.30. This allows you to evaluate several different expressions in one if statement.

Listing 4.30 An if Statement with an else if Statement

Click here to view code image

func main() {
    greet := true
    name := "Janis"

    if greet && name != "" {
        fmt.Println("Hello", name)
    } else if greet {
        fmt.Println("Hello")
    } else {
        fmt.Println("Goodbye")
    }
}

$ go run .

Hello Janis

Go Version: go1.19

Listing 4.30 could also be written with early returns as well as nested if statements. This would result in simpler code that is both more readable and less likely to introduce bugs later on in refactoring.

Assignment Scope

A common operation in Go is to look up a value in a map. When doing this, it is important to check that the item was found in the map. You do this by asking for the second optional boolean value.

In Listing 4.31, the name is looked up, and then an if statement is used to validate that the name was found.

Although doing the lookup and the logic test in two lines of code is fine, it does have one disadvantage, which is that the scope of the age and ok variables are available throughout the entire main function. From a code quality standpoint, any time you can reduce variable scope, you are likely reducing future bugs in your code.

Listing 4.31 Scoping Variables to an if Statement

Click here to view code image

func main() {
    users := map[string]int{
        "Kurt":  27,
        "Janis": 15,
        "Jimi":  40,
    }

    name := "Amy"

    age, ok := users[name]
    if ok {
        fmt.Printf("%s is %d years old
", name, age)
        return
    }

    fmt.Printf("Couldn't find %s in the users map
", name)
}

$ go run .

Couldn't find Amy in the users map

Go Version: go1.19

As such, Go also allows you to create a simple statement before the expression is evaluated. You can use this approach when performing map lookups, as in Listing 4.31, or for other operations that require setting a local variable only for use in the logic expression of the if statement.

To make use of this syntax, you can first write the assignment statement and then use the semicolon followed by the logic expression.

One of the primary advantages of creating the assignment as part of the if statement is that it scopes those variables to the if statement. In Listing 4.32, the age and ok variables are no longer available in the entire scope of the main function but only available within the scope of the if statement. Any time you can reduce the scope of where a variable is used, it results in better code quality because you are less likely to introduce a bug.

Listing 4.32 Scoping Variables to an if Statement

Click here to view code image

func main() {
    users := map[string]int{
        "Kurt":  27,
        "Janis": 15,
        "Jimi":  40,
    }

    name := "Amy"
    if age, ok := users[name]; ok {
        fmt.Printf("%s is %d years old
", name, age)
        return
    }

    fmt.Printf("Couldn't find %s in the users map
", name)
}

$ go run .

Couldn't find Amy in the users map

Go Version: go1.19

Logic and Math Operators

When dealing with logic control statements such as the if statement, understanding how logic operators work can help simplify your code.

While there are several operators, we can break them down into four categories: boolean, mathematical, logical, and bitwise. Tables 4.1 through 4.4 outline these categories.

Table 4.1 Boolean Operators

Operator	Description
&&	Conditional AND
\|\|	Conditional OR
!	NOT

Table 4.2 Mathematical Operators

Operator	Description
+	Sum
-	Difference
*	Product
/	Quotient
%	Remainder (modulus)

Table 4.3 Logic Comparison

Operator	Description
==	Equals
!=	Not equal
<	Less than
<=	Less than or equal
>	Greater than
>=	Greater than or equal

Table 4.4 Bitwise Operators

Operator	Description
&	Bitwise AND
\|	Bitwise OR
^	Bitwise XOR
&^	Bit clear (AND NOT)
«	Left shift
»	Right shift

`Switch` Statements

Switch statements allow for the same type of logic decisions as if statements but tend to be easier to read.

Consider Listing 4.33. The large amount of if/else if statements make it difficult to read and maintain.

Listing 4.33 A Complex Set of if/else if Statements

Click here to view code image

func main() {
    month := 3

    if month == 1 {
        fmt.Println("January")
    } else if month == 2 {
        fmt.Println("February")
    } else if month == 3 {
        fmt.Println("March")
    } else if month == 4 {
        fmt.Println("April")
    } else if month == 5 {
        fmt.Println("May")
    } else if month == 6 {
        fmt.Println("June")
    } else if month == 7 {
        fmt.Println("July")
    } else if month == 8 {
        fmt.Println("August")
    } else if month == 9 {
        fmt.Println("September")
    } else if month == 10 {
        fmt.Println("October")
    } else if month == 11 {
        fmt.Println("November")
    } else if month == 12 {
        fmt.Println("December")
    }
}

$ go run .

March

Go Version: go1.19

The switch statement is a more compact way to write the same logic. In Listing 4.34, we are able to replace the if/else if statements with a switch statement and use the case keyword to evaluate the expression. Each case statement is evaluated in order, and the first one that evaluates to true is used.

Listing 4.34 A Long Version of a switch Statement

Click here to view code image

func main() {
    month := 3

    switch {
    case month == 1:
        fmt.Println("January")
    case month == 2:
        fmt.Println("February")
    case month == 3:
        fmt.Println("March")
    case month == 4:
        fmt.Println("April")
    case month == 5:
        fmt.Println("May")
    case month == 6:
        fmt.Println("June")
    case month == 7:
        fmt.Println("July")
    case month == 8:
        fmt.Println("August")
    case month == 9:
        fmt.Println("September")
    case month == 10:
        fmt.Println("October")
    case month == 11:
        fmt.Println("November")
    case month == 12:
        fmt.Println("December")
    }
}

$ go run .

March

Go Version: go1.19

In Listing 4.34, there is no expression provided to the switch statement. However, the switch statement allows for the use of an expression on the initial line. This removes the need to repeat the month == part of the statement on each line. In Listing 4.35, we use the switch statement to evaluate the month variable. Each case statement can then be simplified to case N, where N is the number of the month.

Listing 4.35 The switch Statement with a Variable

Click here to view code image

func main() {
    month := 3

    switch month {
    case 1:
        fmt.Println("January")
    case 2:
        fmt.Println("February")
    case 3:
        fmt.Println("March")
    case 4:
        fmt.Println("April")
    case 5:
        fmt.Println("May")
    case 6:
        fmt.Println("June")
    case 7:
        fmt.Println("July")
    case 8:
        fmt.Println("August")
    case 9:
        fmt.Println("September")
    case 10:
        fmt.Println("October")
    case 11:
        fmt.Println("November")
    case 12:
        fmt.Println("December")
    }
}

Default

When using a switch statement, if none of the cases are matched, a default block can be used, as in Listing 4.36.

Listing 4.36 Using a default Case with a switch Statement

Click here to view code image

func main() {
    month := 13

    switch month {
    case 1:
        fmt.Println("January")
    case 2:
        fmt.Println("February")
    case 3:
        fmt.Println("March")
    case 4:
        fmt.Println("April")
    case 5:
        fmt.Println("May")
    case 6:
        fmt.Println("June")
    case 7:
        fmt.Println("July")
    case 8:
        fmt.Println("August")
    case 9:
        fmt.Println("September")
    case 10:
        fmt.Println("October")
    case 11:
        fmt.Println("November")
    case 12:
        fmt.Println("December")
    default:
        fmt.Println("Invalid Month")
    }
}

$ go run .

Invalid Month

Go Version: go1.19

Fallthrough

When there is a need to match more than one condition, you can use fallthrough to allow more than one case to be matched. (See Listing 4.37.)

Listing 4.37 Using fallthrough with a switch Statement

Click here to view code image

func RecommendActivity(temp int) {

    fmt.Printf("It is %d degrees out. You could", temp)

    switch {
    case temp <= 32:
        fmt.Print(" go ice skating,")
        fallthrough
    case temp >= 45 && temp < 90:
        fmt.Print(" go jogging,")
        fallthrough
    case temp >= 80:
        fmt.Print(" go swimming,")
        fallthrough
    default:
        fmt.Print(" or just stay home.
")
    }
}

func main() {
    RecommendActivity(19)
    RecommendActivity(45)
    RecommendActivity(90)
}

$ go run .

It is 19 degrees out. You could go ice skating, go jogging,
go swimming, or just stay home.
It is 45 degrees out. You could go jogging, go swimming, or
just stay home.
It is 90 degrees out. You could go swimming, or just stay home.

Go Version: go1.19

Summary

In this chapter, we explored maps in Go. We explained how to declare and use maps and how to use control structures such as if and switch statements. We discussed that maps need to be initialized before they can be used. We showed you how to check for key existence, how to delete a key, and how to iterate over a map.

With this chapter, we have now covered most of the basic data types, operators, keywords, functions, and control structures in Go. With this knowledge, you can now begin to delve into more interesting, and fun, topics. If at any point in the rest of this book you start to feel lost, the answers are most likely in Chapters 1 through 4.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.