golang function indefinite parameters

During the development process, we often encounter situations where we need to pass an indefinite number of parameters. For example, calculating the sum of two or more numbers, or printing a string. At this time, we can use the characteristics of indefinite parameters of Go language functions to solve the problem.

The Go language uses the form of... to represent the variable parameters of a function. The types of variable parameters can be the same or different. When using indefinite parameters, the function can receive any number of parameters, which can be an empty set or a set containing multiple elements.

1. Basic syntax of indefinite parameter function

The following is a simple example that defines a function that uses... to represent indefinite parameters, and then traverses the parameter array And print it out:

func Sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

The function of the above function is to calculate the sum of a set of integers. Next, we call this function:

Sum(1, 2, 3, 4)
Sum(1, 2, 3)

The running results are as follows:

[1 2 3 4] 10
[1 2 3] 6

It can be seen that we called the Sum function twice at one time, passing four parameters in the first time, and Three parameters were passed, and the corresponding sums were successfully calculated.

2. Using slices for indefinite parameter functions

We can use slices to handle indefinite parameter functions. When using variable parameters in slices, we can load all parameters into the slice first, and then use the slice for subsequent operations.

In the following example, we first use the make() method to initialize the slice containing all parameters, then traverse the slice and calculate the sum:

func Sum(nums ...int) {
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

We call the Sum() function again, The parameters passed are the same as before:

nums := []int{1, 2, 3, 4}
Sum(nums...)

The running result of this function is the same as before, the output:

10

3. Used in combination with ordinary parameters

Varies Parametric functions can be very useful in combination with ordinary parameters. For example, we can use a variable-argument function with a string parameter that represents the information to be printed. For example:

func PrintStrings(separator string, strs ...string) {
    fmt.Println(strings.Join(strs, separator))
}

The function of this function is to connect some strings through the specified separator and then print them out. We first call this function and pass the three strings to be connected and the connection symbol:

PrintStrings(", ", "a", "b", "c")

The running results are as follows:

a, b, c

4. Details of using the variable parameter function

When using indefinite parameter functions, we need to pay attention to some details. Here are some details to note:

• The indefinite parameter must be the last parameter of the function.
• You need to pay attention to the priority between variable parameter functions and ordinary functions.
• Indefinite parameters can be passed as parameters of the function, and the values ​​of these parameters can be modified using pointer operations.

5. Summary

Using the variable parameter function can conveniently handle a dynamic number of parameters, which makes it easier and more flexible when writing code. It should be noted that when calling a variable parameter function, we need to pass in the parameters in the prescribed manner.

Through this article, we learned the syntax of function parameters in Go language, and how to use variable parameter functions to handle a dynamic number of parameters. In development, rational use of variable parameter functions will greatly improve the quality and efficiency of the code.

The above is the detailed content of golang function indefinite parameters. For more information, please follow other related articles on the PHP Chinese website!