你可以使用一个包含形参的结构体:

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})

与省略号(params…SomeType)相比，其主要优点是可以将param结构体与不同的形参类型一起使用。

我最终使用了参数和可变参数结构的组合。这样，我就不需要改变现有的由多个服务使用的接口，而且我的服务能够根据需要传递额外的参数。golang playground中的示例代码:https://play.golang.org/p/G668FA97Nu

对于任意的、数量可能很大的可选参数，一个很好的习惯用法是使用Functional选项。

对于你的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

如果需要强制参数，将它们作为构造函数的第一个参数添加到可变参数选项之前。

Functional options成语的主要好处是:

你的API可以随着时间的推移而增长，而不会破坏现有的代码，因为当需要新的选项时，构造函数签名保持不变。 它使默认用例变得最简单:根本没有参数! 它对复杂值的初始化提供了很好的控制。

这个技巧是由Rob Pike创造的，也由Dave Cheney演示过。

你可以使用一个包含形参的结构体:

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})

与省略号(params…SomeType)相比，其主要优点是可以将param结构体与不同的形参类型一起使用。

我有点晚了，但如果你喜欢流畅的界面，你可能会为链式调用设计你的setter:

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不支持可选参数、默认值和函数重载，但你可以使用一些技巧来实现相同的功能。

分享一个例子，你可以在一个函数中有不同数量和类型的参数。这是一个简单易懂的代码，你需要添加错误处理和一些逻辑。

func student(StudentDetails ...interface{}) (name string, age int, area string) {
    age = 10 //Here Age and area are optional params set to default values
    area = "HillView Singapore"

    for index, val := range StudentDetails {
        switch index {
            case 0: //the first mandatory param
                name, _ = val.(string)
            case 1: // age is optional param
                age, _ = val.(int)
            case 2: //area is optional param
                area, _ = val.(string)
        }
    }
    return
}

func main() {
    fmt.Println(student("Aayansh"))
    fmt.Println(student("Aayansh", 11))
    fmt.Println(student("Aayansh", 15, "Bukit Gombak, Singapore"))
}