Uncover the secrets of Golang function parameter passing

Go function parameter passing has two methods: value passing and reference passing. Passing by value copies the parameter value to the function, which will not affect the calling variable; passing by reference passes the parameter memory address reference, and function modification will affect the calling variable.

Uncover the mystery of Golang function parameter passing

In the Go language, the way function parameters are passed is crucial to the behavior of the code. It's important. This article will delve into the mechanism behind Go function parameter passing and demonstrate their capabilities through practical examples.

Transmission method

There are two transfer methods for function parameters in Go: value transfer and reference transfer.

Value passing

Value passing refers to copying the value of the parameter into the function. This means that any modifications to parameter values ​​within a function will not affect the value of the variable that calls the function.

func changeValue(a int) {
    a = 10
}

func main() {
    var a = 5
    changeValue(a)
    fmt.Println(a) // 输出：5
}

In this case, a copy of a is passed to the changeValue function. Modifications in the function only affect the local copy, while the variable calling the function remains unchanged.

Passing by reference

Passing by reference means passing a reference to the memory address of the parameter. This means that any modification to the parameter value in the function will affect the value of the variable that calls the function.

func changeValue(a *int) {
    *a = 10
}

func main() {
    var a = 5
    changeValue(&a)
    fmt.Println(a) // 输出：10
}

In this case, &a is passed a reference to the memory address of the variable a. changeValue The function can modify the value of the original variable through pointer dereference.

Select the delivery method

Select the parameter delivery method depends on the following factors:

• Whether the variable of the calling function needs to be modified Value: Pass by reference if required.
• Parameter type: Value types such as structures and slices use value passing, while reference types such as pointers and channels use reference passing.

Practical Case

The following is a practical case that shows the difference between passing by value and passing by reference:

func main() {
    // 值传递
    var s1 = []int{1, 2, 3}
    modifySlice(s1) // 传递副本
    fmt.Println(s1) // 输出：[]int{1, 2, 3}

    // 引用传递
    var s2 = []int{1, 2, 3}
    modifySliceRef(&s2) // 传递引用
    fmt.Println(s2) // 输出：[]int{4, 5, 6}
}

func modifySlice(s []int) {
    s[0] = 4
}

func modifySliceRef(s *[]int) {
    (*s)[0] = 4
}

In this case , modifySlice accepts slices passed by value, so modifications in the function do not affect the variable calling the function. And modifySliceRef accepts slices by reference, so modifications in the function affect the variable of the calling function.

The above is the detailed content of Uncover the secrets of Golang function parameter passing. For more information, please follow other related articles on the PHP Chinese website!