Detailed explanation of variable length parameter passing in Golang function

Golang is a programming language that has received widespread attention in recent years. It has performed well in many aspects. Among them, variable-length parameter passing of functions is a relatively special feature, which has a very practical effect on summarizing functions and reducing code redundancy. Next, let's explore in detail the variable-length parameter passing of functions in Golang.

1. The basic concept of variable-length parameter passing

In Golang, like some other programming languages, functions can accept zero or more input parameters. Variable-length parameter passing is a special syntax that allows any number of parameters to be passed to a function. Specifically, variable-length parameter passing means specifying that the parameters are variable-length by adding "..." to the function parameter list, so that any number of parameters can be accepted.

The following is the basic format for passing variable-length parameters:

func func_name(args ...type) return_type{

// function body

}

Among them, args is the variable parameter, type is the variable type, and return_type is the function return type.

It should be noted that all values ​​of variable-length parameters are packed in a slice and passed to variable parameters.

2. How to use variable-length parameters

The use of variable-length parameters is very flexible and diverse. Next, we will use a sample program to learn more about how to use this feature.

Suppose we need to implement a function that can receive three types of input parameters: integers, strings and floating point numbers, add them up, sum them up and print them out. A simpler and more crude method is to write three different functions to handle different types of input parameters, but this will make the code redundant and clumsy. Using variable-length parameter passing, we can solve this problem elegantly.

The code is as follows:

package main

import (

"fmt"

)

func Add(nums ...interface{}) float64 {

var sum float64
for _, val := range nums {
    switch v := val.(type) {
    case int:
        sum += float64(v)
    case float64:
        sum += v
    case string:
        fmt.Println("Cannot add a string")
        continue
    }
}
return sum

}

func main() {

fmt.Println(Add(1, 2, 3, 4, 5))
fmt.Println(Add(1.0, 2.0, 3.0, 4.0))
fmt.Println(Add("hello", "world", "golang"))

}

We define an Add function, which has a variable length parameter nums, The return value is float64 type. Inside the function, we first initialize a sum variable to store the sum of all input parameters. Then use a for loop and range to traverse the var parameter list, and perform different processing according to different input types.

In this example, we use switch type judgment. When the input parameter is of type int, we convert it to type float64 and add it to the sum; when the input parameter is of type float64, it is added directly to the sum; when the input parameter is of type string, we print an error message, and skip this parameter.

In the main function, we call the Add function respectively and pass different types of parameters. This is the power of variadic parameters: no matter how many parameters you pass in of different types, they can all be handled by a function without having to write a function for each type.

3. The essence of variable-length parameters

Variable-length parameters are essentially slice types, that is to say, instead of passing each input parameter to the function one by one, they are packaged into a slice and passed to variable parameters. This makes passing variable-length arguments more efficient than passing a large number of individual arguments.

You can use the classic %v formatting verb to print the value of a variable-length parameter:

func main() {

fmt.Printf("%v

", []string{"a" , "b", "c"})
}

The output is: [a b c]

4. Notes

It should be noted that the variable parameters are in The function's parameter list must be placed last, otherwise a compilation error will occur. The reason is that the variable parameter is equivalent to a slice. If it is defined before other parameters in the parameter list, the compiler cannot determine its length.

In addition, although variable parameters can accept any number of parameters, in order to avoid excessive memory usage, they should be used according to the actual situation.

Conclusion

Variable parameters are an item of Golang functions A very practical feature, it allows us to use more concise and efficient code to process functions with a large number of input parameters. In the process of programming, rational use of variable parameters can improve the readability and stability of the code, and can also make the program easier maintain.

The above is the detailed content of Detailed explanation of variable length parameter passing in Golang function. For more information, please follow other related articles on the PHP Chinese website!