Deleting map entries in Go - Step-by-Step Execution

Concept Flow - Deleting map entries

Start with map initialized

↓

Check if key exists in map?

No→End: Nothing to delete

Yes↓

Delete key from map

↓

Key removed, map updated

↓

End

The flow starts with a map, checks if a key exists, deletes it if found, and ends with the updated map.

Execution Sample

Go

m := map[string]int{"a":1, "b":2, "c":3}
delete(m, "b")
fmt.Println(m)

This code deletes the key "b" from the map and prints the updated map.

Execution Table

Step	Operation	Map State	Key Checked	Action	Resulting Map
1	Initialize map	{}	N/A	Create map with keys a,b,c	{"a":1, "b":2, "c":3}
2	Check key existence	{"a":1, "b":2, "c":3}	"b"	Key exists	No change
3	Delete key	{"a":1, "b":2, "c":3}	"b"	Delete key "b"	{"a":1, "c":3}
4	Print map	{"a":1, "c":3}	N/A	Output map	{"a":1, "c":3}
5	End	{"a":1, "c":3}	N/A	No more operations	Final map state

💡 Key "b" deleted, map no longer contains "b"

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
m	nil	{"a":1, "b":2, "c":3}	{"a":1, "c":3}	{"a":1, "c":3}

Key Moments - 2 Insights

Why does the map still exist after deleting a key?

Deleting a key removes only that entry; the map itself remains intact as shown in execution_table step 3 and 4.

What happens if we delete a key that does not exist?

Deleting a non-existent key does nothing and does not cause an error, similar to step 2 where key existence is checked.

Visual Quiz - 3 Questions

Look at the execution table, what is the map state after step 3?

A {"a":1, "b":2, "c":3}

B {"a":1, "c":3}

C {"b":2, "c":3}

D {}

💡 Hint

Check the 'Resulting Map' column at step 3 in the execution_table.

At which step is the key "b" confirmed to exist before deletion?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Key Checked' and 'Action' columns in the execution_table.

If we tried to delete key "d" which is not in the map, what would happen?

A Map would be unchanged

B Program would crash

C All keys would be deleted

D Key "d" would be added

💡 Hint

Refer to key_moments about deleting non-existent keys and execution_table step 2.

Concept Snapshot

Deleting map entries in Go:
- Use delete(map, key) to remove a key.
- If key exists, it is removed; map stays valid.
- Deleting a non-existent key does nothing.
- Map remains usable after deletion.
- No error occurs when deleting missing keys.

Full Transcript

This visual trace shows how deleting a key from a Go map works. We start with a map containing keys a, b, and c. We check if key b exists, then delete it. After deletion, the map no longer contains b but still has a and c. Printing the map confirms the change. Deleting a key does not remove the map itself. If a key does not exist, deleting it does nothing and causes no error.

Practice

1. What does the built-in delete function do in Go when used as delete(myMap, key)?

easy

A. Adds a new entry with the specified key to the map.

B. Returns the value associated with the key.

C. Clears all entries from the map.

D. Removes the entry with the specified key from the map if it exists.

Solution

1. Step 1: Understand the delete function purpose

   The delete function is used to remove a key and its value from a map.

2. Step 2: Analyze the effect of delete on the map

   When called as delete(myMap, key), it removes the entry if the key exists; otherwise, it does nothing.

3. Final Answer:

   Removes the entry with the specified key from the map if it exists. -> Option D

4. Quick Check:

   delete removes key from map [OK]

Hint: delete(map, key) removes key entry safely [OK]

Common Mistakes:

• Thinking delete adds or returns values
• Confusing delete with clearing the whole map
• Assuming delete returns a value

2. Which of the following is the correct syntax to delete a key named "user1" from a map called users in Go?

easy

A. delete(users, "user1")

B. users.delete("user1")

C. remove(users, "user1")

D. users.deleteKey("user1")

Solution

1. Step 1: Recall Go's delete syntax

   In Go, the built-in function delete is used as delete(map, key) to remove a key.

2. Step 2: Match the correct syntax

   delete(users, "user1") uses delete(users, "user1"), which is the correct syntax. Other options use methods that do not exist in Go.

3. Final Answer:

   delete(users, "user1") -> Option A

4. Quick Check:

   delete(map, key) syntax correct [OK]

Hint: Use delete(map, key) function, not method calls [OK]

Common Mistakes:

• Using method syntax like map.delete(key)
• Using non-existent functions like remove()
• Confusing with other languages' syntax

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

m := map[string]int{"a": 1, "b": 2}
delete(m, "a")
fmt.Println(m)

medium

A. map[a:1 b:2]

B. map[b:2]

C. map[]

D. Compilation error

Solution

1. Step 1: Understand initial map content

   The map m initially has two entries: "a":1 and "b":2.

2. Step 2: Effect of delete(m, "a")

   The delete call removes the key "a" and its value from the map, leaving only "b":2.

3. Final Answer:

   map[b:2] -> Option B

4. Quick Check:

   Deleting key "a" removes it from map [OK]

Hint: Deleting key removes it; print shows remaining entries [OK]

Common Mistakes:

• Expecting deleted key to remain
• Thinking delete clears whole map
• Assuming syntax error occurs

4. Consider this Go code snippet:

var m map[string]int
delete(m, "key")
fmt.Println("Done")

What will happen when this code runs?

medium

A. Compilation error because delete cannot be used on nil maps.

B. Runtime panic due to deleting from a nil map.

C. Prints "Done" without error.

D. Deletes the key if it exists, then prints "Done".

Solution

1. Step 1: Understand nil map behavior

   In Go, a nil map behaves like an empty map for reads and deletes; deleting a key from a nil map does nothing and does not panic.

2. Step 2: Analyze the code behavior

   Deleting from a nil map is safe and does not cause runtime panic. The program prints "Done" normally.

3. Final Answer:

   Prints "Done" without error. -> Option C

4. Quick Check:

   Deleting from nil map is safe [OK]

Hint: Deleting from nil map is safe, no panic occurs [OK]

Common Mistakes:

• Assuming runtime panic on deleting from nil map
• Thinking delete causes compilation error
• Confusing nil map with uninitialized map variable

5. You have a map m := map[string]int{"x": 10, "y": 0, "z": -5}. You want to delete all keys whose values are zero or less. Which code snippet correctly deletes these entries?

hard

A. for k, v := range m { if v <= 0 { delete(m, k) } }

B. for k := range m { if m[k] < 0 { delete(m, k) } }

C. for k, v := range m { if v == 0 { delete(m, k) } }

D. for k := range m { if m[k] == 0 { delete(m, k) } }

Solution

1. Step 1: Identify keys with values zero or less

   Keys with values <= 0 are "y" (0) and "z" (-5).

2. Step 2: Choose loop that deletes keys with v <= 0

   for k, v := range m { if v <= 0 { delete(m, k) } } uses for k, v := range m and deletes keys where v <= 0, correctly removing "y" and "z".

3. Step 3: Compare other options

   Options A and C check only for == 0, missing negative values like "z":-5. for k := range m { if m[k] < 0 { delete(m, k) } } checks m[k] < 0, missing zero values like "y":0.

4. Final Answer:

   for k, v := range m { if v <= 0 { delete(m, k) } } -> Option A

5. Quick Check:

   Delete keys with value <= 0 using k,v loop [OK]

Hint: Use for k,v range and delete if v <= 0 [OK]

Common Mistakes:

• Deleting only keys with value == 0, missing negatives
• Using only key without value in loop
• Modifying map incorrectly during iteration