What's the Difference Between Capacity and Length in Go Slices?

Understanding the Distinction between Capacity and Length of a Slice

A slice in Go is a data structure that provides a flexible and efficient way to handle collections of values. It operates on an underlying array, offering two key properties: capacity and length.

Capacity

The capacity of a slice refers to the total number of elements that the underlying array can hold. When creating a slice using the make() function, the capacity can be specified as the third argument. For instance:

x := make([]int, 0, 5)

In this case, the slice x has a length of 0 but a capacity of 5.

Length

The length of a slice represents the number of elements it currently contains. When initializing a slice with zero length, as in the example above, the length will also be 0.

Difference between Capacity and Length

While capacity indicates the maximum number of elements the slice can accommodate, length denotes the actual number of non-null values it stores. The length of a slice can never be greater than its capacity, but it can be less than the capacity if not all elements are filled.

Example

For a better understanding, consider the following example:

s := make([]int, 0, 3)
for i := 0; i < 5; i++ {
    s = append(s, i)
}

This code creates a slice with a capacity of 3 and then appends values to it until it reaches capacity. As the capacity is exceeded, the slice will be automatically resized, and its capacity will increase. The output of this code would be:

cap 3, len 1
cap 3, len 2
cap 3, len 3
cap 6, len 4
cap 6, len 5

In this output, the capacity starts at 3 and doubles when the slice reaches its capacity. The length, however, increases with each append operation and represents the number of actual values.

The above is the detailed content of What's the Difference Between Capacity and Length in Go Slices?. For more information, please follow other related articles on the PHP Chinese website!