Необязательные параметры?

Вы можете использовать структуру, которая включает параметры:

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 для программистов на C ++ документы,

Go не поддерживает перегрузку функций и не поддерживает определяемые пользователем операторы.

Я не могу найти столь же ясное утверждение, что необязательные параметры не поддерживаются, но они также не поддерживаются.

Ни необязательные параметры, ни перегрузка функций не поддерживаются в Go. Go поддерживает переменное число параметров: Передача аргументов в ... parameters

Вы можете довольно красиво описать это в функции, аналогичной приведенной ниже.

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

В итоге я использовал комбинацию структуры params и variadic args. Таким образом, мне не пришлось менять существующий интерфейс, который использовался несколькими сервисами, и мой сервис мог передавать дополнительные параметры по мере необходимости. Пример кода на детской площадке Голанга: https://play.golang.org/p/G668FA97Nu

Язык Go не поддерживает перегрузку методов, но вы можете использовать переменные аргументы точно так же, как необязательные параметры, также вы можете использовать интерфейс {} в качестве параметра, но это не очень хороший выбор.

Для произвольного, потенциально большого числа необязательных параметров, хорошая идиома - использовать Функциональные опции .

Для вашего типа 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

Для краткости вы можете дать имя типу из опций ( Playground ):

type OptionFoobar func(*Foobar) error

Если вам нужны обязательные параметры, добавьте их в качестве первых аргументов конструктора перед переменным options.

Основными преимуществами идиомы Функциональные опции являются:

• Ваш API может расти со временем, не нарушая существующий код, потому что сигнатура конструктора остается той же, когда появляются новые опции необходимо.
• он позволяет использовать случай использования по умолчанию как самый простой: никаких аргументов вообще!
• он обеспечивает точный контроль над инициализацией комплексных значений.

Этот метод был придуман Робом Пайком , а также продемонстрирован Дейвом Чейни .

Я немного опаздываю, но если вам нравится свободный интерфейс, вы можете создать сеттеры для цепных вызовов следующим образом:

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, и обладает теми же преимуществами, но имеет некоторые недостатки:

1. Если произойдет ошибка, она не будет немедленно прервана, поэтому , было бы немного менее эффективно, если бы вы ожидали, что ваш конструктор будет часто сообщать об ошибках.
2. Вам придется потратить строку, объявляющую переменную err и обнуляющую ее.

Однако есть небольшое преимущество: вызовы функций такого типа должны быть проще для встроенного компилятора, но я действительно не специалист.

Можно передать произвольные именованные параметры с картой.

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