Map creation in Go - Step-by-Step Execution

Concept Flow - Map creation

Start

↓

Declare map variable

↓

Initialize map with make()

↓

Add key-value pairs

↓

Use map

↓

End

This flow shows how to declare, initialize, and add key-value pairs to a map in Go.

Execution Sample

Go

package main
import "fmt"
func main() {
  var m map[string]int
  m = make(map[string]int)
  m["apple"] = 5
  fmt.Println(m)
}

This code creates a map from strings to integers, adds one key-value pair, and prints the map.

Execution Table

Step	Action	Map State	Output
1	Declare map variable m	map is nil (not initialized)
2	Initialize map with make(map[string]int)	empty map {}
3	Add key "apple" with value 5	{"apple":5}
4	Print map m	{"apple":5}	map[apple:5]
5	Program ends	{"apple":5}

💡 Program ends after printing the map with one key-value pair.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
m	nil	{}	{"apple":5}	{"apple":5}

Key Moments - 2 Insights

Why do we need to use make() to initialize the map?

In step 2, the map is initialized with make(), creating an empty map. Without this, the map is nil and cannot store key-value pairs, so adding keys would cause a runtime error.

What happens if we try to add a key-value pair before initializing the map?

Before step 2, the map is nil (step 1). Adding a key then would cause a runtime panic because the map is not ready to hold data, as shown by the empty map state only after step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the state of map 'm' after step 1?

A nil (not initialized)

B empty map {}

C map with one key-value pair

D map with default values

💡 Hint

Check the 'Map State' column in row for step 1.

At which step does the map 'm' get its first key-value pair?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Map State' columns to see when 'apple':5 is added.

If we skip step 2 (make initialization), what will happen when adding a key-value pair?

A Map will be empty and accept the pair

B Program will panic at runtime

C Map will automatically initialize

D Nothing happens, map stays nil

💡 Hint

Refer to key moment about adding keys before initialization.

Concept Snapshot

Map creation in Go:
- Declare map variable: var m map[string]int
- Initialize with make(): m = make(map[string]int)
- Add key-value: m["key"] = value
- Maps must be initialized before use
- Print with fmt.Println(m)

Full Transcript

This example shows how to create a map in Go. First, we declare a map variable 'm' which is nil initially. Then we initialize it using make(), which creates an empty map ready to store data. Next, we add a key-value pair with key "apple" and value 5. Finally, we print the map, which shows map[apple:5]. Without initialization, adding keys would cause a runtime error. This step-by-step trace helps understand how maps are created and used in Go.

Practice

1. What is the correct way to create an empty map with string keys and int values in Go?

easy

A. m := make(map[string]int)

B. m := map[string]int()

C. m := new(map[string]int)

D. m := []string{}

Solution

1. Step 1: Understand map creation syntax

   In Go, the built-in function make is used to create maps with specified key and value types.

2. Step 2: Identify the correct syntax for an empty map

   make(map[string]int) creates an empty map with string keys and int values.

3. Final Answer:

   m := make(map[string]int) -> Option A

4. Quick Check:

   Use make(map[keyType]valueType) to create maps [OK]

Hint: Use make() with map[keyType]valueType to create maps [OK]

Common Mistakes:

• Using new() instead of make() for maps
• Trying to create map with slice syntax
• Confusing map literal with empty slice

2. Which of the following is a syntax error when creating a map in Go?

easy

A. m := make(map[int]string)

B. m := make(map[float64]int)

C. m := make(map[[]int]string)

D. m := map[int]string{}

Solution

1. Step 1: Check key type validity

   Map keys must be comparable types. Slices ([]int) are not comparable in Go.

2. Step 2: Identify invalid map key type

   Using []int as a key type causes a syntax error because slices cannot be map keys.

3. Final Answer:

   m := make(map[[]int]string) -> Option C

4. Quick Check:

   Map keys must be comparable types [OK]

Hint: Map keys cannot be slices or maps, only comparable types [OK]

Common Mistakes:

• Using slices or maps as map keys
• Confusing map literal with slice literal
• Ignoring key type restrictions

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

m := make(map[string]int)
m["apple"] = 5
m["banana"] = 3
fmt.Println(m["apple"] + m["banana"])

medium

A. 53

B. 8

C. 0

D. Compilation error

Solution

1. Step 1: Understand map assignments

   The map m stores key-value pairs: "apple"=5 and "banana"=3.

2. Step 2: Calculate the sum of values

   Adding m["apple"] (5) and m["banana"] (3) results in 8.

3. Final Answer:

   8 -> Option B

4. Quick Check:

   5 + 3 = 8 [OK]

Hint: Sum map values by accessing keys directly [OK]

Common Mistakes:

• Concatenating values as strings instead of adding
• Expecting zero for existing keys
• Forgetting to initialize map before use

4. Identify the error in the following Go code snippet:

var m map[string]int
m["key"] = 10
fmt.Println(m["key"])

medium

A. No error, prints 10

B. Syntax error in map declaration

C. Key type must be int, not string

D. Map declared but not initialized, causes runtime panic

Solution

1. Step 1: Check map initialization

   The map m is declared but not initialized with make, so it is nil.

2. Step 2: Understand runtime behavior

   Assigning to a nil map causes a runtime panic (error) because the map is not ready to store values.

3. Final Answer:

   Map declared but not initialized, causes runtime panic -> Option D

4. Quick Check:

   Declare + make before use to avoid panic [OK]

Hint: Always initialize maps with make() before adding keys [OK]

Common Mistakes:

• Forgetting to initialize map before assignment
• Assuming declaration alone creates usable map
• Confusing map declaration with slice declaration

5. Given a slice of strings keys := []string{"a", "b", "c"} and a slice of ints values := []int{1, 2, 3}, which code snippet correctly creates a map from keys to values?

hard

A. m := make(map[string]int)
for i := range keys {
m[keys[i]] = values[i]
}

B. m := map[string]int{}
for i, v := range values {
m[v] = keys[i]
}

C. m := make(map[int]string)
for i := 0; i < len(keys); i++ {
m[i] = keys[i]
}

D. m := make(map[string]int)
for i := 0; i < len(values); i++ {
m[values[i]] = keys[i]
}

Solution

1. Step 1: Match keys and values correctly

   Keys are strings, values are ints. The map must have type map[string]int.

2. Step 2: Verify loop and assignment

   m := make(map[string]int) for i := range keys { m[keys[i]] = values[i] } loops over keys and assigns m[keys[i]] = values[i], correctly pairing keys to values.

3. Final Answer:

   m := make(map[string]int) for i := range keys { m[keys[i]] = values[i] } -> Option A

4. Quick Check:

   Loop keys, assign values to map[key] [OK]

Hint: Loop keys, assign values to map[key] for correct pairing [OK]

Common Mistakes:

• Swapping keys and values in map assignment
• Using wrong map key or value types
• Not initializing map before assignment