Clear

The built-in function clear takes an argument of map, slice, or type parameter type, and deletes or zeroes out all elements [[Go 1.21(https://go.dev/ref/spec#Go_1.21)]].

Call        Argument type     Result

clear(m)    map[K]T           deletes all entries, resulting in an
                              empty map (len(m) == 0)

clear(s)    []T               sets all elements up to the length of
                              s to the zero value of T

clear(t)    type parameter    see below

clear is a relatively recent addition to Go, added just over a year ago. And it’s a bit of a funny one, in my personal opinion.

The use with maps makes perfect sense to me.

Do you want to delete everything from an existing map, without creating a new one? clear does that! Yay! It’s not a frequent requirement, but it’s nice that it exists, because there was no good alternative.

m := map[int]int{1: 1, 2: 2, 3: 3}
fmt.Println(m, len(m)) // map[1:1 2:2 3:3] 3
clear(m)
fmt.Println(m, len(m)) // map[] 0

The weird thing about clear is that its behavior on slices is not very analogous, at least not to my way of thinking. When operating on a slice, clear just zeros out the values.

s := []int{1, 2, 3, 4, 5}
fmt.Println(s, len(s), cap(s)) // [1 2 3 4 5] 5 5
clear(s)
fmt.Println(s, len(s), cap(s)) // [0 0 0 0 0] 5 5

I suppose the reason for this is that you can accomplish “deleting” everything in a slice very easily without clear:

s := []int{1, 2, 3, 4, 5}
fmt.Println(s, len(s), cap(s)) // [1 2 3 4 5] 5 5
s = s[:0]
fmt.Println(s, len(s), cap(s)) // [] 0 5

If the type of the argument to clear is a type parameter, all types in its type set must be maps or slices, and clear performs the operation corresponding to the actual type argument.

If the map or slice is nil, clear is a no-op.

I’m also unsure why clear doesn’t work on arrays directly. It’s easy enough to work around, though, if you want to:

a := [...]int{1, 2, 3, 4, 5}
fmt.Println(a, len(a), cap(a)) // [1 2 3 4 5] 5 5
// clear(a) // invalid argument: cannot clear a (variable of type [5]int)
clear(a[:])
fmt.Println(a, len(a), cap(a)) // [0 0 0 0 0] 5 5

Quotes from The Go Programming Language Specification Language version go1.23 (June 13, 2024)