How do slices in Golang modify the original array even though they are passed to functions by value?

Passing Arrays to Functions and Modifying Them in Golang

In programming languages like C , arrays are implicitly passed by reference when passed to functions. However, in Golang, this behavior is different, which can be confusing for those coming from other languages.

The Difference: Arrays vs. Slices

In the provided code example:

<code class="go">func main() {
    tab := []int{1, 2, 3}
    fmt.Println(tab)
    reverse(tab)
    fmt.Println(tab)
}

func reverse(tab []int) {
    for i, j := 0, len(tab)-1; i < j; i, j = i+1, j-1 {
        tab[i], tab[j] = tab[j], tab[i]
    }
}</code>

It appears that the array is passed by value (not reference), but the reverse function still modifies the original array. The key here is that in Golang, "tab" is not an array but a slice.

Slices in Go

Slices are lightweight data structures that represent a contiguous section of an array. They consist of a pointer to the underlying array, a length, and a capacity. When a slice is passed to a function, only the header information (pointer, length, capacity) is copied, not the entire underlying array.

Passing Slices by Reference

Therefore, any changes made to the slice within the function affect the underlying array, as they are pointing to the same data. In the above example, the reverse function modifies the elements of the slice, which in turn affects the original array tab.

Conclusion

While arrays in Go are passed by value (copy), slices are passed by reference (share underlying data). Understanding this distinction is crucial when passing arrays or slices to functions in Golang to avoid unexpected behavior.

The above is the detailed content of How do slices in Golang modify the original array even though they are passed to functions by value?. For more information, please follow other related articles on the PHP Chinese website!