How to use function argument passing in Go?

Go is a strongly typed programming language, and its function parameters are passed by value. This means that when you pass a parameter to a function, you are actually making a copy of the parameter's value and passing that value to the function for processing. Therefore, when using function parameter passing in Go, you need to pay attention to the following points:

1. The difference between value types and reference types

In Go, in addition to basic data types Except for value types, all data types are reference types. When a value type data is passed as a function parameter, a copy of the value will be copied and passed to the function; when a reference type data is passed as a function parameter, the address of the data in memory will be passed.

For example, let’s look at the parameter passing process of value type and reference type respectively:

package main

import "fmt"

func main() {
    // 值类型参数传递
    var a = 10
    fmt.Println("Before call func: ", a) // 输出 10

    changeByVal(a)

    fmt.Println("After call func: ", a) // 输出 10

    // 引用类型参数传递
    var b = []int{1, 2, 3}
    fmt.Println("Before call func: ", b) // 输出 [1 2 3]

    changeByRef(b)

    fmt.Println("After call func: ", b) // 输出 [4 5]
}

// 值类型参数传递
func changeByVal(num int) {
    num = 100
}

// 引用类型参数传递
func changeByRef(arr []int) {
    arr[0] = 4
    arr[1] = 5
}

We can see that in the case of value type parameter passing, even if the parameter is passed inside the function, The parameter value is modified to 100, but the external a variable is still not affected. In the case of passing reference type parameters, the parameter is modified inside the function, and the actual data outside the function is also affected.

2. Pointer type parameter passing

When we want to change the reference type data, we can use pointer type parameter passing. Pointer is a data type that stores the address of a variable, which is also passed by value in Go.

We can use the & operator to get the address of a variable, and the * operator to get the data stored in the address.

For example:

package main

import "fmt"

func main() {
    var a = 10
    var b *int

    b = &a

    fmt.Println("Before call func: ", a) // 输出 10

    changeByPtr(b)

    fmt.Println("After call func: ", a) // 输出 100
}

func changeByPtr(num *int) {
    *num = 100
}

We can find that the data pointed to by the pointer (original variable a) is modified inside the function, and the actual external data is also affected.

3. Use... to represent variable-length parameters

If our function needs to receive variable-length parameters, we can also use... to represent it. This syntax is similar to args and kwargs in Python.

For example:

package main

import "fmt"

func main() {
    printNames("John", "Alice", "Bob")
}

func printNames(names ...string) {
    for _, name := range names {
        fmt.Println(name)
    }
}

In this example, we define a function printNames with variable length parameters, and the parameter type it receives is string. Inside the function, we use range to iterate through all parameters and output their values ​​one by one.

Summary

In Go, function parameter passing is by value, so you need to pay attention to the difference between value types and reference types. When you need to modify reference type data, you can use pointer type parameter passing. In addition, we can also use... to represent variable-length parameters, making it easier for the function to receive parameters of variable length.

The above is the detailed content of How to use function argument passing in Go?. For more information, please follow other related articles on the PHP Chinese website!