Length and capacity

The built-in functions len and cap take arguments of various types and return a result of type int. The implementation guarantees that the result always fits into an int.

Recall that int is either a 32- or 64-bit integer. So this means that the theoretical maximum length or capacity of the various types that support len and cap depends on the CPU architecture.

However, this should not matter in practice, since you’d quickly exceed the available memory, before you had a slice, array, map, or other item with 2^32 elements in it.

Well, okay, maybe not. You can actually create slices or arrays of elements that take up zero bytes. But these are still limited to the max value of a positive int on compilation CPU architecture.

a := [1<<63 - 1]struct{}{}
fmt.Println(unsafe.Sizeof(a), len(a)) // Prints: 0 9223372036854775807

So I hope 9.2 quintillion nothings (or a mere 2.1 billion if you’re still using a 32-bit system) is enough for you.

Call      Argument type    Result

len(s)    string type      string length in bytes
          [n]T, *[n]T      array length (== n)
          []T              slice length
          map[K]T          map length (number of defined keys)
          chan T           number of elements queued in channel buffer
          type parameter   see below

cap(s)    [n]T, *[n]T      array length (== n)
          []T              slice capacity
          chan T           channel buffer capacity
          type parameter   see below

In short, len is useful for reading the current number of elements in a: string, array, slice, map, or channel, whereas cap is useful for reading the maximum capacity of an array, slice, or channel. The length and capacity of an array are equal, by definition.

If the argument type is a type parameter P, the call len(e) (or cap(e) respectively) must be valid for each type in P’s type set. The result is the length (or capacity, respectively) of the argument whose type corresponds to the type argument with which P was instantiated.

This means the following code would be valid:

func X[T []int, map[int]int]myLen(x T) int {
	return len(x) // Both []int and map[int]int support `len`
}

But this would not:

func X[T []int, map[int]int]myCap(x T) int {
	return cap(x) // map[int]int does not support `cap
}

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