How to remove a key from a map in Go

1The delete builtinRecommended

delete(m, key) removes the key and its value from the map. It is a statement, not an expression: there is no return value to inspect and nothing to assign. Crucially, deleting a key that was never in the map is a defined no-op — Go simply does nothing, where Python would raise KeyError and JavaScript would hand you back a meaningless true. That means you never need to guard a delete.

package main

import "fmt"

func main() {
	ports := map[string]int{"http": 80, "https": 443, "ssh": 22, "ftp": 21}
	fmt.Println(len(ports))

	delete(ports, "ftp")  // removes the key and its value
	delete(ports, "smtp") // never there -- a silent no-op, not an error
	fmt.Println(len(ports))

	// A deleted key is now just a missing key
	fmt.Println(ports["ftp"])
	_, ok := ports["ftp"]
	fmt.Println(ok)
}

Prints 4, then 3 after the two deletes — only one of them changed anything. The last two lines show what the key became: ports["ftp"] is 0, the value type's zero value, and the comma-ok check reports false. delete on a nil map is a no-op too, which is unusual — writing to a nil map panics, but deleting from one does not.

2Delete only if the key was there

Because delete returns nothing, it can't tell you whether it removed anything. When you need to know — logging a removal, decrementing a counter, returning the old value — do a comma-ok lookup first and delete inside the if. That is Go's equivalent of Python's dict.pop(key, default), and it costs one extra hash lookup.

package main

import "fmt"

// pop deletes key k and reports the value it held, if any.
func pop(m map[string]int, k string) (int, bool) {
	v, ok := m[k]
	if ok {
		delete(m, k)
	}
	return v, ok
}

func main() {
	stock := map[string]int{"pens": 12, "chairs": 0}

	if v, ok := pop(stock, "pens"); ok {
		fmt.Println("removed pens:", v)
	}

	// A stored zero is still a real entry -- only ok can prove it was there
	if v, ok := pop(stock, "chairs"); ok {
		fmt.Println("removed chairs:", v)
	}

	v, ok := pop(stock, "desks")
	fmt.Println(v, ok, len(stock))
}

Prints removed pens: 12, removed chairs: 0, then 0 false 0. The middle line is the point: chairs held a legitimate 0, so testing if stock[k] != 0 before deleting would have skipped it. Maps are reference types, so pop mutates the caller's map — no pointer needed, and no copy is made when you pass one to a function.

3Deleting while you range

In many languages, mutating a collection you are iterating is undefined behaviour or an outright exception. Go explicitly allows it: the spec says entries removed during iteration simply will not be produced, and entries you delete behind the cursor are already done. So filtering a map in place is a plain range loop with a delete in it — no second pass, no copy of the keys.

package main

import "fmt"

func main() {
	scores := map[string]int{"ann": 91, "bob": 45, "cy": 78, "dee": 12}

	// Deleting during range is explicitly allowed by the spec
	for name, score := range scores {
		if score < 50 {
			delete(scores, name)
		}
	}
	_, hasBob := scores["bob"]
	fmt.Println(len(scores), hasBob)

	// Deleting the entry you are standing on never skips the others:
	// the loop still visits every key that is left
	visited := 0
	for name := range scores {
		visited++
		delete(scores, name)
	}
	fmt.Println(visited, len(scores))
}

Prints 2 false — bob and dee are gone — then 2 0: the second loop still visited both survivors even though it deleted each one as it went. Adding during a range is the risky direction: a key created mid-loop may or may not be produced later, so the result is genuinely unspecified. Note also that the loop deliberately never prints the map directly — Go randomises iteration order, so sort the keys first when output must be stable.

4Removing every key: clear vs make vs nil

To empty a map, Go 1.21 added the clear builtin: clear(m) deletes every entry and keeps the same map. The older move — m = make(map[string]int) — looks equivalent but isn't: it points m at a different map, so any other variable, struct field, or goroutine still holding the original sees an unchanged map. Setting m = nil is a third thing again: readable and deletable, but the next write panics.

package main

import "fmt"

func main() {
	m := map[string]int{"a": 1, "b": 2, "c": 3}
	alias := m // two variables, one map

	clear(m) // Go 1.21+: deletes every key, keeps the map
	fmt.Println(len(m), len(alias))

	m["a"] = 1
	fmt.Println(len(m), len(alias))

	m = make(map[string]int) // a brand-new map; alias still holds the old one
	fmt.Println(len(m), len(alias))

	var gone map[string]int // nil: safe to read, panics on write
	fmt.Println(gone == nil, len(gone))
	delete(gone, "a") // deleting from a nil map is a no-op too
	fmt.Println(len(gone))
}

clear prints 0 0 — both views empty — and the write after it prints 1 1, because they are still the same map. The make line prints 0 1: m is fresh, alias kept the old contents. Then true 0 for the nil map and 0 after deleting from it. Before 1.21 the idiom was for k := range m { delete(m, k) }, which the compiler already special-cased into the same fast path clear uses.

5Which should you use?

6Deleting many keys — and the memory that stays

maps.DeleteFunc (Go 1.21+) deletes every entry matching a predicate, which is the in-place filter from section 3 with the loop written for you. Dropping a known list of keys is just a loop of delete calls — no existence checks, because misses are free. But neither shrinks the map: Go's runtime never releases a map's bucket array, so a map that held a million entries still occupies that space after you delete them all. If the purge was huge and the map is long-lived, copy the survivors into a fresh map and let the old one be collected.

package main

import (
	"fmt"
	"maps"
	"slices"
)

// Maps have no order, so sort the keys before printing anything.
func sortedKeys(m map[string]int) []string {
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	slices.Sort(keys)
	return keys
}

func main() {
	scores := map[string]int{"ann": 91, "bob": 45, "cy": 78, "dee": 12}

	// Go 1.21+: delete every entry matching a predicate
	maps.DeleteFunc(scores, func(_ string, score int) bool { return score < 50 })
	fmt.Println(sortedKeys(scores))

	// Dropping a known list of keys -- the ones that aren't there cost nothing
	for _, k := range []string{"cy", "nobody"} {
		delete(scores, k)
	}
	fmt.Println(sortedKeys(scores))

	// Rebuilding is the only way to hand the old buckets back to the GC
	big := map[string]int{"ann": 91, "bob": 45, "cy": 78, "dee": 12}
	keep := make(map[string]int, len(big))
	for k, v := range big {
		if v >= 50 {
			keep[k] = v
		}
	}
	fmt.Println(len(keep), sortedKeys(keep))
}

Prints [ann cy], then [ann] after the two deletes — one hit, one miss — then 2 [ann cy] from the rebuilt map. Sizing the new map with make(map[string]int, len(big)) avoids rehashing as it grows. The memory caveat is real but easy to over-apply: for maps that churn between a floor and a ceiling, delete and clear reusing those buckets is the point — only rebuild when the high-water mark is far above the steady state and the map outlives the spike.