Go可以有可选参数吗? 还是可以只定义两个具有相同名称和不同数量参数的函数?
您可以使用包含以下参数的结构:
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})
一种实现类似可选参数的好方法是使用可变参数。 该函数实际上会接收您指定的任何类型的切片。
func foo(params ...int) {
fmt.Println(len(params))
}
func main() {
foo()
foo(1)
foo(1,2,3)
}
Go没有可选参数, 也不支持方法重载 :
如果方法分派也不需要进行类型匹配,则可以简化方法分派。 其他语言的经验告诉我们,使用具有相同名称但签名不同的多种方法有时会很有用,但在实践中也可能会造成混淆和脆弱。 在Go的类型系统中,仅按名称进行匹配并要求类型一致是一个简化的主要决定。
不-都不。 根据Go for C ++程序员文档,
Go不支持函数重载,也不支持用户定义的运算符。
我找不到一个同样明确的说法,即不支持可选参数,但也不支持它们。
Go既不支持可选参数,也不支持函数重载。 Go确实支持可变数量的参数:将参数传递给...参数
对于任意的,可能大量的可选参数,一个好习惯是使用Functional options 。
对于您的Foobar
类型,首先只编写一个构造函数:
func 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
。
功能选项惯用法的主要优点是:
该技术由Rob Pike创造,也由Dave Cheney演示。
我最终使用了params和可变参数args的组合结构。 这样,我不必更改多个服务使用的现有接口,并且我的服务能够根据需要传递其他参数。 Golang游乐场中的示例代码: https : //play.golang.org/p/G668FA97Nu
您可以将其很好地封装在类似于下面的函数中。
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 ->
我来晚了一点,但是如果您喜欢流畅的界面,可以像下面这样设计链式呼叫的设置器:
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
变量并将其清零。 但是,这可能会有一个小的优势,这种类型的函数调用应该更易于编译器内联,但我并不是专家。
Go语言不支持方法重载,但是您可以像使用可选参数一样使用可变参数args,也可以使用interface {}作为参数,但这不是一个好选择。
您可以将任意命名参数与映射一起传递。
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})
}