Why Does Golang\'s `append()` Seem to Modify a Slice After It\'s Sent Over a Channel?

When Does Golang append() Create a New Slice?

The documentation for append() indicates that it will allocate a new slice and copy the elements when the capacity of the original slice is insufficient. However, a discrepancy arises when examining the output of the following code, which generates combinations of a boolean alphabet.

<code class="go">package main

import (
    "fmt"
)

func AddOption(c chan []bool, combo []bool, length int) {
    if length == 0 {
        fmt.Println(combo, "!")
        c <- combo
        return
    }
    var newCombo []bool
    for _, ch := range []bool{true, false} {
        newCombo = append(combo, ch)
        AddOption(c, newCombo, length-1)
    }
}

func main() {
    c := make(chan []bool)
    go func(c chan []bool) {
        defer close(c)
        AddOption(c, []bool{}, 4)
    }(c)
    for combination := range c {
        fmt.Println(combination)
    }
}</code>

Contrasting Observations

In the output, the lines ending with an exclamation mark represent slices sent over the channel by AddOption, while the lines without an exclamation mark show the slices received in main(). Noticeably, the slices sent over the channel appear to be modified after being sent, despite append() allegedly returning a new slice.

Examining the Source

The questionable codeblock is:

<code class="go">var newCombo []bool
for _, ch := range []bool{true, false} {
    newCombo = append(combo, ch)
    AddOption(c, newCombo, length-1)
}</code>

According to the documentation, append() should return a new slice descriptor pointing to a new underlying data array when the capacity of the original slice is not sufficient. However, the passed value as the second argument to AddOption may be either a pointer to a slice descriptor or a genuine copy of the slice descriptor.

Clarifying the Behavior

The answer to this question lies in distinguishing between the slice data type and its actual representation. A slice descriptor consists of two integers for length and capacity, along with a pointer to the underlying data.

While append() does return a new slice descriptor with a potentially different underlying data array, the pointer to the data remains the same unless the capacity is expanded. This means that while the slice descriptor itself is a copy, the pointer value (address to the underlying data) is shared.

Additional Example

For illustration, consider this code snippet:

<code class="go">package main

import "fmt"

func main() {
    s := make([]int, 0, 5)
    s = append(s, []int{1, 2, 3, 4}...)

    a := append(s, 5)
    fmt.Println(a)

    b := append(s, 6)
    fmt.Println(b)
    fmt.Println(a)
}</code>

This code prints:

[1 2 3 4 5]
[1 2 3 4 6]
[1 2 3 4 6]

Initially, s has enough capacity, so a and b share the same underlying data pointer. However, if we reduce the capacity of s to 4, the output changes to:

[1 2 3 4 5]
[1 2 3 4 6]
[1 2 3 4 5]

This demonstrates that a and b only share the same underlying data when s has sufficient capacity.

The above is the detailed content of Why Does Golang\'s `append()` Seem to Modify a Slice After It\'s Sent Over a Channel?. For more information, please follow other related articles on the PHP Chinese website!