Default value in Go's method

Is there a way to specify default value in Go's function? I am trying to find this in the documentation but I can't find anything that specifies that this is even possible.

func SaySomething(i string = "Hello")(string){
...
}

NO,but there are some other options to implement default value. There are some good blog posts on the subject, but here are some specific examples.

Option 1: The caller chooses to use default values

// Both parameters are optional, use empty string for default value
func Concat1(a string, b int) string {
  if a == "" {
    a = "default-a"
  }
  if b == 0 {
    b = 5
  }

  return fmt.Sprintf("%s%d", a, b)
}

Option 2: A single optional parameter at the end

// a is required, b is optional.
// Only the first value in b_optional will be used.
func Concat2(a string, b_optional ...int) string {
  b := 5
  if len(b_optional) > 0 {
    b = b_optional[0]
  }

  return fmt.Sprintf("%s%d", a, b)
}

Option 3: A config struct

// A declarative default value syntax
// Empty values will be replaced with defaults
type Parameters struct {
  A string `default:"default-a"` // this only works with strings
  B string // default is 5
}

func Concat3(prm Parameters) string {
  typ := reflect.TypeOf(prm)

  if prm.A == "" {
    f, _ := typ.FieldByName("A")
    prm.A = f.Tag.Get("default")
  }

  if prm.B == 0 {
    prm.B = 5
  }

  return fmt.Sprintf("%s%d", prm.A, prm.B)
}

Option 4: Full variadic argument parsing (javascript style)

func Concat4(args ...interface{}) string {
  a := "default-a"
  b := 5

  for _, arg := range args {
    switch t := arg.(type) {
      case string:
        a = t
      case int:
        b = t
      default:
        panic("Unknown argument")
    }
  }

  return fmt.Sprintf("%s%d", a, b)
}

No, the powers that be at Google chose not to support that.

https://groups.google.com/forum/#!topic/golang-nuts/-5MCaivW0qQ

No, there is no way to specify defaults. I believer this is done on purpose to enhance readability, at the cost of a little more time (and, hopefully, thought) on the writer's end.

I think the proper approach to having a "default" is to have a new function which supplies that default to the more generic function. Having this, your code becomes clearer on your intent. For example:

func SaySomething(say string) {
	// All the complicated bits involved in saying something
}

func SayHello() {
	SaySomething("Hello")
}

With very little effort, I made a function that does a common thing and reused the generic function. You can see this in many libraries, fmt.Println for example just adds a newline to what fmt.Print would otherwise do. When reading someone's code, however, it is clear what they intend to do by the function they call. With default values, I won't know what is supposed to be happening without also going to the function to reference what the default value actually is.

A default function argument usually provides the client code with a very common argument value while still allowing the client code to override it. A similar result can be achieved by turning the function into a method of a struct and the default argument into a field of that struct.

Let's see it with a function based on your example (it doesn't compile):

func SaySomething(msg string = "Hello") string {
	return fmt.Sprintf("I say %q", msg)
}

First, define a struct that will hold the default argument:

type SomethingSayer struct {
	msg string
}

Second, turn the function SaySomething into a method on the struct SomethingSayer. The original function parameter msg is replaced by s.msg, a SomethingSayer's field:

func (s SomethingSayer) SaySomething() string {
	return fmt.Sprintf("I say %q", s.msg)
}

You can also define a constructor for the SomethingSayer struct. This will set the field msg with the original default argument:

func NewSaySomethingSayer() SomethingSayer {
	return SomethingSayer {
		msg: "Hello", // the default argument
	}
}

Finally, define a convenience wrapping function that is like the original one but without the parameter that had the default argument:

func SaySomething() string {
	return NewSaySomethingSayer().SaySomething()
}

This way, the client code can just call SaySomething() when the defaults are suitable. If that's not the case, it can still construct its own SomethingSayer and then call the SaySomething() method:

fmt.Println(SaySomething())    // I say "Hello"

s := SomethingSayer {
	msg: "Bye",
}
fmt.Println(s.SaySomething())  // I say "Bye"

Note that this approach is also followed by the standard library in http.Get, http.Head, and http.Post. That is, this function allows you to perform a GET request without explicitly constructing a http.Client: it uses a globally available http.Client value (http.DefaultClient) and calls its Get method on it. Similarly, client code can still override the default arguments (e.g., the timeout) by constructing its own http.Client and calling Get on it.