Go可以有可选参数吗？ 还是可以只定义两个具有相同名称和不同数量参数的函数？
#1楼
您可以使用包含以下参数的结构：
type Params struct {
a, b, c int
}
func doIt(p Params) int {
return p.a + p.b + p.c
}
// you can call it without specifying all parameters
doIt(Params{a: 1, c: 9})
#2楼
一种实现类似可选参数的好方法是使用可变参数。 该函数实际上会接收您指定的任何类型的切片。
func foo(params ...int) {
fmt.Println(len(params))
}
func main() {
foo()
foo(1)
foo(1,2,3)
}
#3楼
Go没有可选参数， 也不支持方法重载 ：
如果方法分派也不需要进行类型匹配，则可以简化方法分派。 其他语言的经验告诉我们，使用具有相同名称但签名不同的多种方法有时会很有用，但在实践中也可能会造成混淆和脆弱。 在Go的类型系统中，仅按名称进行匹配并要求类型一致是一个简化的主要决定。
#4楼
不-都不。 根据Go for C ++程序员文档，
Go不支持函数重载，也不支持用户定义的运算符。
我找不到一个同样明确的说法，即不支持可选参数，但也不支持它们。
#5楼
Go既不支持可选参数，也不支持函数重载。 Go确实支持可变数量的参数：将参数传递给...参数
#6楼
对于任意的，可能大量的可选参数，一个好习惯是使用Functional options 。
Foobarfunc NewFoobar(options ...func(*Foobar) error) (*Foobar, error){
fb := &Foobar{}
// ... (write initializations with default values)...
for _, op := range options{
err := op(fb)
if err != nil {
return nil, err
}
}
return fb, nil
}
其中每个选项都是使Foobar发生变化的函数。 然后为您的用户提供方便的方式来使用或创建标准选项，例如：
func OptionReadonlyFlag(fb *Foobar) error {
fb.mutable = false
return nil
}
func OptionTemperature(t Celsius) func(*Foobar) error {
return func(fb *Foobar) error {
fb.temperature = t
return nil
}
}
为简洁起见，您可以为选项的类型命名（ Playground ）：
type OptionFoobar func(*Foobar) error
options功能选项惯用法的主要优点是：
- 您的API可以随着时间的增长而不会破坏现有代码，因为当需要新的选项时，构造器签名保持不变。
- 它使默认用例变得最简单：根本没有参数！
- 它提供了对复杂值的初始化的精细控制。
该技术由Rob Pike创造，也由Dave Cheney演示。
#7楼
我最终使用了params和可变参数args的组合结构。 这样，我不必更改多个服务使用的现有接口，并且我的服务能够根据需要传递其他参数。 Golang游乐场中的示例代码： https ： //play.golang.org/p/G668FA97Nu
#8楼
您可以将其很好地封装在类似于下面的函数中。
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
fmt.Println(prompt())
}
func prompt(params ...string) string {
prompt := ": "
if len(params) > 0 {
prompt = params[0]
}
reader := bufio.NewReader(os.Stdin)
fmt.Print(prompt)
text, _ := reader.ReadString('\n')
return text
}
在此示例中，提示默认情况下在前面有一个冒号和一个空格。 。 。
:
。 。 。 但是，您可以通过为提示函数提供参数来覆盖它。
prompt("Input here -> ")
这将导致如下提示。
Input here ->
#9楼
我来晚了一点，但是如果您喜欢流畅的界面，可以像下面这样设计链式呼叫的设置器：
type myType struct {
s string
a, b int
}
func New(s string, err *error) *myType {
if s == "" {
*err = errors.New(
"Mandatory argument `s` must not be empty!")
}
return &myType{s: s}
}
func (this *myType) setA (a int, err *error) *myType {
if *err == nil {
if a == 42 {
*err = errors.New("42 is not the answer!")
} else {
this.a = a
}
}
return this
}
func (this *myType) setB (b int, _ *error) *myType {
this.b = b
return this
}
然后这样称呼它：
func main() {
var err error = nil
instance :=
New("hello", &err).
setA(1, &err).
setB(2, &err)
if err != nil {
fmt.Println("Failed: ", err)
} else {
fmt.Println(instance)
}
}
这类似于@Ripounet答案上的“ 功能选项”惯用语，具有相同的优点，但有一些缺点：
err但是，这可能会有一个小的优势，这种类型的函数调用应该更易于编译器内联，但我并不是专家。
#10楼
Go语言不支持方法重载，但是您可以像使用可选参数一样使用可变参数args，也可以使用interface {}作为参数，但这不是一个好选择。
#11楼
您可以将任意命名参数与映射一起传递。
type varArgs map[string]interface{}
func myFunc(args varArgs) {
arg1 := "default" // optional default value
if val, ok := args["arg1"]; ok {
// value override or other action
arg1 = val.(string) // runtime panic if wrong type
}
arg2 := 123 // optional default value
if val, ok := args["arg2"]; ok {
// value override or other action
arg2 = val.(int) // runtime panic if wrong type
}
fmt.Println(arg1, arg2)
}
func Test_test() {
myFunc(varArgs{"arg1": "value", "arg2": 1234})
}