There are three new builtin functions in Go 1.21. Compared to the previous functions len
, cap
, delete
, append
, close
, panic
and so on, there are new changes, let’s take a look at them.
clear
clear has always been a function that everyone wanted, and this new function has been added to manipulate map and slice objects.
1

func clear[T ~[]Type  ~map[Type]Type1](t T)

 For map object: clear function clears all the elements of the map object
 For the slice object: the clear function sets all elements to the zero value of the element type, with the same length and the same capacity
Write a program to test that it is indeed as described above:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

func testClear() {
m := map[float64]bool{100: true, 1000: true, math.NaN(): true, math.NaN(): true}
delete(m, math.NaN())
fmt.Printf("before clear, m len: %d\n", len(m))
clear(m)
fmt.Printf("after clear, m len: %d\n", len(m))
s := make([]float64, 0, 1024*1024)
for i := 0; i < 10; i++ {
s = append(s, float64(i))
}
fmt.Printf("before clear, s len: %d, s cap: %d\n", len(s), cap(s))
clear(s)
fmt.Printf("after clear, s len: %d, s cap: %d\n", len(s), cap(s))
fmt.Println(s)
}

Run gotip run main.go
, and output the result.
1
2
3
4
5

before clear, m len: 4
after clear, m len: 0
before clear, s len: 10, s cap: 1048576
after clear, s len: 10, s cap: 1048576
[0 0 0 0 0 0 0 0 0 0]

min and max functions
These two newly added functions for finding the maximum and minimum values are much more convenient than math.Max
and math.Min
.
First of all, the types supported are Ordered types, the types that can do +
operations can be parameters, such as string types can also be, and secondly, it also supports indeterminate length parameters, which is convenient to use.
For example, the following call.
1
2
3
4
5
6
7
8
9

var x, y int
m := min(x) // m == x, Individual parameters are fine!
m := min(x, y) // m is the smallest of x and y
m := max(x, y, 10) // m is the largest of x, y, 10, i.e., at least 10
c := max(1, 2.0, 10) // c == 10.0 (Floatingpoint arithmetic)
f := max(0, float32(x)) // float32
var s []string
_ = min(s...) // Invalid: The slice parameter is not supported
t := max("", "foo", "bar") // t == "foo" (Support string)

For the limit values of floatingpoint numbers, the following rules apply.
1
2
3
4
5

x y min(x, y) max(x, y)
0.0 0.0 0.0 0.0 // Negative zero is less than positive zero
Inf y Inf y // Negative infinity is smaller than other numbers
+Inf y y +Inf // Positive infinity over other numbers
NaN y NaN NaN // As long as one parameter is NaN, the return of these two functions will be NaN

Strings are compared by byte.
Ref
https://colobu.com/2023/05/28/go121whatsnewbuiltin/