How Do Go Slices Interact with Their Underlying Arrays?

Unveiling the Mystery of Slice Underlying Arrays in Go

In the realm of Go programming, slices act as a flexible way to handle collections of data without the need for pre-fixed lengths. They provide a dynamic mechanism for accessing a contiguous sequence of elements. However, when working with slices, it's often essential to understand the underlying array they reference.

Consider this scenario: we have an integer array of length 3:

nums := [3]int{1, 2, 3}

Creating a slice by slicing the first two elements:

numSlice := nums[:2]

In this case, cap on both numSlice and nums is 3, indicating the underlying array's capacity, while len is 2 and 3, respectively. Now, if we append an element to numSlice:

numSlice = append(numSlice, 10)

The underlying array nums changes to [1 2 10], indicating that numSlice still references the original array. The capacity remains 3 for both numSlice and len.

However, upon the second append operation:

numSlice = append(numSlice, 20)

The underlying array of numSlice must change due to its capacity being reached. This new underlying array is reflected in the doubled capacity and an updated len of 4 for numSlice.

Retrieving the Reference to the New Array

To access the newly created underlying array, we can leverage the combination of reflect and unsafe packages in Go. The reflect.SliceHeader struct provides a field named Data, which contains a pointer to the underlying array of a slice.

s := []int{1, 2, 3, 4}
hdr := (*reflect.SliceHeader)(unsafe.Pointer(&s))
data := *(*[4]int)(unsafe.Pointer(hdr.Data))

By utilizing this technique, you can access and manipulate the underlying array directly, granting you deeper control over the data management in your Go programs.

The above is the detailed content of How Do Go Slices Interact with Their Underlying Arrays?. For more information, please follow other related articles on the PHP Chinese website!