Why doesn\'t appending to a Go slice affect the original slice when they share the same underlying array?

Understanding Append Behavior on Slices

In Go, slices are a convenient way to manage collections of data. However, their behavior can sometimes be confusing, particularly when performing operations such as appending elements.

Consider the following code snippet:

func main() {
    slice := make([]int, 10, 10)
    slice[0] = 0
    slice[1] = 1

    slice1 := slice
    slice1[0] = 10000
    fmt.Println(slice)

    slice1 = append(slice1, 100)
    slice1[0] = 20000

    fmt.Println(slice)
}

The expected output would be a list of items where the first of slice has changed to 10000 after the first append, and then to 20000 after the second append. Additionally, we would expect the items in slice to reflect these changes as well, since both slice and slice1 point to the same underlying array.

However, the actual output is surprising:

[10000 1 0 0 0 0 0 0 0 0]
[10000 1 0 0 0 0 0 0 0 0]

The first output, as expected, shows that slice1 successfully changed the value of the first element to 10000. However, the second output reveals that the subsequent append operation and changes to slice1 did not affect slice. Why is this so?

Understanding Go's Value Semantics

The key to understanding this behavior lies in Go's value semantics. In Go, variables are passed by value, meaning that when you assign a variable to another variable, a copy of the value is made. This applies to slices as well.

When you perform slice1 := slice, you are creating a copy of the slice header. The slice header contains information about the length, capacity, and the pointer to the underlying array. However, the underlying array itself is not copied.

Append Behavior

When you perform an append operation, a new slice header is created and a new underlying array is allocated. The elements from the original slice are copied into the new array, and the new slice header is returned.

In our example, when you perform slice1 = append(slice1, 100), a new slice header is created and a new array is allocated with space for the existing elements plus the additional element to be appended. The elements from slice1 are copied into the new array, and the new slice header is assigned to slice1.

Importantly, slice still points to the original underlying array, which is why the changes made to slice1 are not reflected in slice.

Conclusion

To understand append behavior on slices, it is crucial to remember that slices are passed by value. When appending elements, a new slice header and underlying array are created, leaving the original slice unaffected.

The above is the detailed content of Why doesn\'t appending to a Go slice affect the original slice when they share the same underlying array?. For more information, please follow other related articles on the PHP Chinese website!