How Do Value and Pointer Semantics Differ in Go, and How Do Slices Exhibit Exceptional Behavior?

Understanding Value Semantics and Pointer Semantics in Go

In Go, understanding the concepts of value semantics and pointer semantics is crucial for comprehending the inner workings of arrays and slices.

Value Semantics

When values are passed to functions or methods in Go, copies of those values are created. These copies are isolated from the original values, meaning any modifications made within the function or method will not affect the original values.

For example, consider the following code:

func double(i int) int {
    i *= 2
    return i
}

func main() {
    i := 1
    fmt.Println("double:", double(i))
    fmt.Println("original i:", i)
}

The output of this code demonstrates value semantics:

double: 2
original i: 1

Even though double() modifies its i parameter, the i variable in the calling function remains unchanged. This is because a copy of i was passed to double().

Pointer Semantics

Unlike value semantics, pointer semantics refer to cases where a pointer to a value is passed instead of the value itself. When a pointer is modified within a function or method, the changes are reflected in the original value.

Consider the following code:

func doublep(i *int) int {
    *i *= 2
    return *i
}

func main() {
    i := 1
    fmt.Println("double:", doublep(&i))
    fmt.Println("original i:", i)
}

The output of this code demonstrates pointer semantics:

double: 2
original i: 2

In this example, a pointer to i is passed to doublep(), allowing the function to modify the original value of i directly.

Passing Slices: An Exception to Value Semantics

Although Go follows value semantics, arrays and slices exhibit pointer semantics. When a slice is passed to a function or method, a copy of the slice header (not the underlying array) is created. However, both the original and copied slices reference the same underlying array. Therefore, modifications to the elements of the slice within the function or method are reflected in the original slice.

This behavior is evident in the following code:

func doubles(is []int) []int {
    for i := range is {
        is[i] *= 2
    }
    return is
}

func main() {
    is := []int{1, 2}
    fmt.Println("double:", doubles(is))
    fmt.Println("original is:", is)
}

Output:

double: [2 4]
original is: [2 4]

Understanding value and pointer semantics is essential for working effectively with data in Go. It allows developers to anticipate the behavior of functions and methods when manipulating values.

The above is the detailed content of How Do Value and Pointer Semantics Differ in Go, and How Do Slices Exhibit Exceptional Behavior?. For more information, please follow other related articles on the PHP Chinese website!