How Does Slicing Affect Go Slice Capacity?

Understanding Slice Capacity Reduction

Go slices are efficient data structures that use an underlying array for storage. They are represented by a combination of length and capacity, where capacity defines the maximum number of elements that the slice can hold.

Slice Capacity Changes

Manipulating a slice can sometimes affect its capacity:

• s = s[:0] and s = s[:4] leave the slice capacity unchanged because they do not modify the underlying pointer to the array.
• s = s[2:] decreases the slice capacity because it changes the pointer to the new slice by dropping the first two elements.

Example

Consider the following Go program:

package main

import "fmt"

func main() {
    s := []int{2, 3, 5, 7, 11, 13}
    printSlice(s)

    s = s[:0]
    printSlice(s)

    s = s[:4]
    printSlice(s)

    s = s[2:]
    printSlice(s)
}

func printSlice(s []int) {
    fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

Running this program outputs:

len=6 cap=6 [2 3 5 7 11 13]
len=0 cap=6 []
len=4 cap=6 [2 3 5 7]
len=2 cap=4 [5 7]

Explanation

Initially, the slice has a length of 6 and a capacity of 6. Changing its length to 0 does not modify the pointer, so the capacity remains unchanged. Extending the length to 4 also keeps the capacity the same. However, slicing the slice from the 2nd element onwards (s = s[2:]) changes the pointer, resulting in a new slice with a length of 2 and a capacity of 4.

Data Recovery

s = s[2:] removes the first two elements from the slice. If you need to recover them, you will need to create a new slice that includes them before performing the s = s[2:] operation.

Memory Representation of Slices

Understanding the memory representation of slices is crucial for comprehending why the capacity of s = s[2:] decreases:

• When a slice is created, it points to an underlying array.
• Slicing a slice does not allocate a new array. Instead, it creates a new slice value with a different pointer to the original array.
• Changing the pointer effectively reassigns the slice to point to a different part of the underlying array. This can affect the capacity.

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