Question

我正在学习Go。

在JavaScript中，通过将参数封装在对象中来定义一个接受多个无序参数的函数是微不足道的：

// define our function
var foo = function(params) {
  // ... don't care
};

// specify parameters as an object literal
var params = {
  alpha:   true,
  bravo:   10,
  charlie: "delta",
};

// pass the params to the function
foo(options);

在Go中实现这一目标的惯用方法是什么？我知道Go有哈希，结构，类型和接口，但我不确定哪个最好用在这里。

请注意，我想导出有问题的功能，以便在自己的包装之外使用。

Answer 1

同样的道理。将它们封装在结构中。

type FooParameters struct {
    Alpha   bool
    Bravo   int
    Charlie string
}

func Foo(params FooParameters) {
    fmt.Print(params.Charlie)
    // ... don't care
}

func main() {
    // Any order is fine
    params := FooParameters{
        Bravo:   10,
        Charlie: "delta",
        Alpha:   true,
    }
    Foo(params)
}

https://play.golang.org/p/cU0Jd7_jN8

你问过匿名结构，并且它们是惯用的（它们不时出现在stdlib中），但它们使用起来有点痛苦，所以你通常不需要它们，除非结构是非常小，非常少用。例如，这是您的界面与匿名结构的外观。

func Foo(params struct {
    Alpha   bool
    Bravo   int
    Charlie string
}) {
    fmt.Print(params.Charlie)
    // ... don't care
}

func main() {
    // Any order is fine
    params := struct {
        Alpha   bool
        Bravo   int
        Charlie string
    }{
        Bravo:   10,
        Charlie: "delta",
        Alpha:   true,
    }
    Foo(params)
}

https://play.golang.org/p/r4yXh7oADe

阅读IMO非常困难，而且需要输入很多东西。命名类型只是一种方便。在使用命名类型的任何地方，您都可以使用匿名类型（但正如Milo所说，您通常不应该这样做。）

Answer 2

您可以使用此结构。这种方式a内部函数成为切片 - 这就是为什么我将第一个元素作为a[0]返回。限制 - 只有最后一个参数可以是可变参数。

func f(a... int) int {
    return a[0]
}

如何接受：

严格按顺序排列任意数量的参数：您可以传递一个非常抽象的类型 - 空interface{}然后调用

func f(a... interface{}) interface{} {
    return a[0]
}
f("aaa", 2, []int{3,4})

但是不要太用太多了:) - 你失去了静态典型化的所有好处。

固定类型和参数数量：使用struct。

任意数量的无序参数：将其作为map[interface{}]interface{}传递：

func b(m map[interface{}]interface{}) {
    fmt.Println(m)
}

https://play.golang.org/p/0MeMm9x0JT

接受无序函数参数的惯用法

2 个答案: