Why Does Slicing a Go Slice Reduce Its Capacity?

Slicing a Slice: Understanding Capacity Changes

When working with slices in Go, it's crucial to grasp the concept of capacity. Capacity refers to the maximum number of elements a slice can hold without reallocating its underlying array. While slicing doesn't copy the underlying data, it can affect the capacity.

Why Does s = s[2:] Decrease Capacity?

When you slice a slice, you create a new slice header that points to a portion of the original underlying array. The capacity of the new slice is determined by the segment of the array it references.

In the given code, s = s[:4] creates a slice that references the first four elements of the array. The capacity remains unchanged at 6 since the slice still points to the same underlying array.

However, s = s[:0] results in a zero-length slice with a capacity of 6. This is because the slice now points to the beginning of the array, so there's ample space for expansion.

When you execute s = s[2:], you drop the first two elements of the slice. This changes the pointer to the new slice, causing it to point further down the underlying array. Consequently, the capacity is reduced to 4 because there are only four usable elements left in the array after the slice.

Recovering the Cut-Off Elements

Once elements are dropped from a slice, they cannot be recovered using the same variable since you are modifying the underlying array. If you need to preserve these elements, you can create a new slice that references the original slice.

Memory Representation of Slices

To better understand slice capacity, visualize how slices are represented in memory:

• make([]byte, 5) creates a slice with an underlying byte array of size 5.
• The array has an address and size, stored in the slice header.
• When you slice this array to s = s[2:4], a new slice header is created that points to the third and fourth element of the underlying array.
• The capacity of this slice is determined by the number of usable elements in the array after the slice. In this case, it's 3, leaving the remaining 2 unusable elements.

The above is the detailed content of Why Does Slicing a Go Slice Reduce Its Capacity?. For more information, please follow other related articles on the PHP Chinese website!