Accessing map values in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a map in Go?

A map in Go is a collection of key-value pairs where each key is unique and is used to access its corresponding value.

beginner

How do you access a value from a map in Go?

You access a value by using the key inside square brackets after the map variable, like: value := myMap[key].

beginner

What happens if you try to access a key that does not exist in a Go map?

Go returns the zero value of the map's value type (e.g., 0 for int, "" for string) if the key is not found.

intermediate

How can you check if a key exists in a Go map when accessing its value?

You can use the two-value assignment: value, ok := myMap[key]. The 'ok' is true if the key exists, false otherwise.

intermediate

Why is it useful to check if a key exists in a Go map before using its value?

Because accessing a non-existent key returns a zero value, which might be misleading. Checking existence helps avoid bugs by confirming the key is present.

How do you access the value for key "name" in a Go map called 'person'?

A person["name"]

B person.name

C person->name

D person.get("name")

In Go, map values are accessed using square brackets with the key inside, like person["name"].

What does Go return if you access a key that does not exist in a map?

A An error is thrown

B The zero value of the map's value type

C nil

D The last inserted value

Go returns the zero value for the map's value type if the key is missing, without throwing an error.

Which syntax correctly checks if a key exists in a Go map?

A value, ok := myMap[key]

B value := myMap[key]

C exists := myMap.contains(key)

D if myMap[key] != nil

The two-value assignment 'value, ok := myMap[key]' lets you check if the key exists with 'ok'.

What type is the variable 'ok' when checking map key existence in Go?

A int

B string

C bool

D interface{}

'ok' is a boolean that is true if the key exists, false otherwise.

Why might you want to check if a key exists before using its value from a map?

A To avoid runtime errors

B To delete the key

C To get the zero value

D To confirm the key is present and avoid using default zero values mistakenly

Checking existence helps avoid confusion caused by zero values returned for missing keys.

Explain how to access a value from a map in Go and how to check if the key exists.

Think about how you get a value and also know if it is really there.

Describe what happens when you access a key that does not exist in a Go map and why checking existence is important.

Consider what Go returns and how that might confuse your program.

Practice

1. What does the expression value, ok := myMap["key"] do in Go?

easy

A. It retrieves the value for "key" and checks if the key exists in the map.

B. It deletes the key "key" from the map.

C. It adds a new key "key" with value "ok" to the map.

D. It returns the number of keys in the map.

Solution

1. Step 1: Understand map access syntax

   In Go, value, ok := myMap["key"] retrieves the value for the key and a boolean indicating if the key exists.

2. Step 2: Explain the boolean ok

   The ok is true if the key is present, false otherwise.

3. Final Answer:

   It retrieves the value for "key" and checks if the key exists in the map. -> Option A

4. Quick Check:

   Map access with existence check = value, ok [OK]

Hint: Remember: value, ok checks key presence in map [OK]

Common Mistakes:

• Thinking it deletes the key
• Assuming it adds a key
• Confusing it with map length

2. Which of the following is the correct way to check if a key exists in a Go map named m for key k?

easy

A. value, ok := m[k]; if ok { ... }

B. value := m[k]; if value != nil { ... }

C. if m.contains(k) { ... }

D. if m[k] != 0 { ... }

Solution

1. Step 1: Recall Go map existence check syntax

   In Go, to check if a key exists, use value, ok := m[k] and then check ok.

2. Step 2: Analyze options

   value := m[k]; if value != nil { ... } wrongly assumes value is nil for missing keys, which is not always true. if m.contains(k) { ... } uses a method that does not exist. if m[k] != 0 { ... } checks value but zero value can be valid.

3. Final Answer:

   value, ok := m[k]; if ok { ... } -> Option A

4. Quick Check:

   Use value, ok to check key presence [OK]

Hint: Use value, ok := map[key] to check key existence [OK]

Common Mistakes:

• Checking value against nil or zero instead of ok
• Using non-existent map methods
• Assuming zero value means key missing

3. What will be the output of this Go code?

m := map[string]int{"a": 10, "b": 20}
value, ok := m["c"]
fmt.Println(value, ok)

medium

A. Compilation error

B. 0 true

C. 20 true

D. 0 false

Solution

1. Step 1: Understand map lookup for missing key

   Key "c" is not in map m, so value gets zero value for int, which is 0, and ok is false.

2. Step 2: Print output values

   Printing value and ok prints "0 false".

3. Final Answer:

   0 false -> Option D

4. Quick Check:

   Missing key returns zero value and false [OK]

Hint: Missing map keys return zero value and false [OK]

Common Mistakes:

• Assuming missing key returns true
• Expecting runtime error for missing key
• Confusing zero value with actual stored value

4. Identify the error in this Go code snippet:

m := map[string]int{"x": 5}
value := m["y"]
if value {
    fmt.Println("Key exists")
}

medium

A. Missing declaration of map m.

B. Map key "y" does not exist, causing runtime panic.

C. Cannot use int value as boolean in if condition.

D. Syntax error in map initialization.

Solution

1. Step 1: Analyze the if condition

   The variable value is an int, but Go requires a boolean expression in if conditions.

2. Step 2: Understand Go type rules

   Using an int directly as a boolean causes a compile-time error.

3. Final Answer:

   Cannot use int value as boolean in if condition. -> Option C

4. Quick Check:

   if conditions need boolean, not int [OK]

Hint: if needs boolean, not int value [OK]

Common Mistakes:

• Assuming missing key causes panic
• Ignoring type mismatch in if condition
• Thinking map declaration is missing

5. Given a map m := map[string]int{"a": 1, "b": 0, "c": 3}, how can you print only keys that exist and have a non-zero value?

hard

A. for k := range m { if m[k] { fmt.Println(k) } }

B. for k, v := range m { if v != 0 { fmt.Println(k) } }

C. for k, v := range m { if m[k] != nil { fmt.Println(k) } }

D. for k, v := range m { if v { fmt.Println(k) } }

Solution

1. Step 1: Iterate over map with key and value

   Use for k, v := range m to get keys and values.

2. Step 2: Check for non-zero values

   Check if v != 0 to filter keys with non-zero values.

3. Step 3: Print keys that meet condition

   Print the key k inside the if block.

4. Final Answer:

   for k, v := range m { if v != 0 { fmt.Println(k) } } -> Option B

5. Quick Check:

   Filter keys by value != 0 using range loop [OK]

Hint: Use for k,v := range map and check v != 0 [OK]

Common Mistakes:

• Using value as boolean directly
• Checking map key against nil
• Ignoring zero values in condition