Optional functional parameters in Go

The Problem

You want to write functions with optional parameters in Go, but the language doesn’t support this feature.

The Solution

While Go doesn’t support optional parameters, you can approximate them with variadic functions or zero values.

Variadic Functions

In Go, functions can specify a type of parameter that contains zero or more values.

For example, the sum() function accepts any number of integer (int) parameters and adds them together:

package main

import "log"

func sum(numbers ...int) int {
	result := 0
	for _, n := range numbers {
		result += n
	}

	return result
}

func main() {
	log.Println(sum())        // Prints "0".
	log.Println(sum(1))       // Prints "1".
	log.Println(sum(1, 2, 3)) // Prints "6".
}

Variadic functions must specify the variadic parameter as the final parameter.

• For example, the following variadic function is valid:

  func sum(start int, numbers ...int) int

• Whereas the following variadic function is not:

  func sum(numbers ...int, start int) int

Zero Values

You can simulate some of the functions of optional parameters by specifying a struct as the parameter of a function in Go. Functions with struct parameters have default zero-value arguments. The argument is assumed to be 0 when left empty for these functions.

package main

import "log"

type operations struct {
	// initialValue will be 0 if not specified.
	initialValue int
	// So will add and subtract.
	add, subtract int
	// doubleResult will be false if not specified.
	doubleResult bool
}

func calculate(ops operations) int {
	result := ops.initialValue
	result += ops.add
	result -= ops.subtract

	if ops.doubleResult {
		result *= 2
	}

	return result
}

func main() {
	log.Println(calculate(operations{}))                                                         // Prints "0".
	log.Println(calculate(operations{initialValue: 1}))                                          // Prints "1".
	log.Println(calculate(operations{initialValue: 1, add: 5}))                                  // Prints "6".
	log.Println(calculate(operations{initialValue: 1, add: 5, subtract: 2, doubleResult: true})) // Prints "8".

	// Or, using unnamed fields:
	log.Println(calculate(operations{1, 5, 2, true})) // Prints "8".
}

While the potential default values are limited, this approach is useful for specific cases.

Further Reading

• The Variadic function Wikipedia article
• The zero value section of The Go Programming Language Specification