如何在Go中提供可选参数？

I'm coming from a Node.js background, and there a typical pattern is to have a function which takes an options object, i.e. an object where you set properties for optional parameters, such as:

foo({
  bar: 23,
  baz: 42
});

This is JavaScript's "equivalent" to optional and named parameters.

Now I have learnt that there are no optional parameters in Go, except variadic parameters, but they lack the readability of named parameters. So the usual pattern seems to be to hand over a struct.

OTOH a struct can not be defined with default values, so I need a function to set up the struct.

So I end up with:

• Call a function that creates the struct and then fills it with default values.
• Overwrite the values I would like to change.
• Call the function I actually want to call and hand over the struct.

That's quite complicated and lengthy compared to JavaScript's solution.

Is this actually the idiomatic way of dealing with optional and named parameters in Go, or is there a simpler version?

Is there any way that you can take advantage of zero values? All data types get initialized to a zero value, so that is a form of default logic.

An options object is a pretty common idiom. The etcd client library has some examples (SetOptions,GetOptions,DeleteOptions) similar to the following.

type MyOptions struct {
    Field1 int      // zero value (default) of int is 0
    Field2 string   // zero value (default) of string is ""
}

func DoAction(arg1, arg2 string, options *MyOptions){
    var defaultValue1 int = 30        // some reasonable default
    var defaultValue2 string = "west" // some reasonable default

    if options != nil {
        defaultValue1 = options.Field1 // override with our values
        defaultValue2 = options.Field2 
    }
    doStuffWithValues

An relevant question (and very much in the mindset of Go) would be, do you need this kind of complexity? The flexibility is nice, but most things in the standard library try to only deal with 1 default piece of info/logic at a time to avoid this.

Whether this approach is useful depends on the scenario but in some case at least you could use a map for this.

If all the options are of the same type use map[string]type. That gives you named options and as few or many as you want.

Their existence is easy to test for with something like

if val, exists := opts["bar"]; exists {
    // Do something here
}

To set the default values you can use a map literal when creating the map.

If the options are not of the same type you can use map[string]interface{} which will allow any type to be stored in the map. You'll just need to typecast the values after retrieving.