Go Option Pattern Implementation Guide

In Go language, you can use the Function Option design pattern to implement the Option pattern.

The function option design pattern is a way to use optional parameters in function calls. It allows for more flexibility in function calls by selectively passing parameters based on the needs without the need for numerous overloaded functions or parameter combinations.

The key to implementing the option design pattern with functions is to use variadic parameters and function types. By defining an Option type as a function type that accepts a parameter and modifies it as needed.

Below is a simple example demonstrating how to implement the function options design pattern in the Go language.

package main

import "fmt"

type Options struct {
	Name   string
	Age    int
	Height float64
}

type Option func(*Options)

// 设置姓名
func WithName(name string) Option {
	return func(opt *Options) {
		opt.Name = name
	}
}

// 设置年龄
func WithAge(age int) Option {
	return func(opt *Options) {
		opt.Age = age
	}
}

// 设置身高
func WithHeight(height float64) Option {
	return func(opt *Options) {
		opt.Height = height
	}
}

func NewOptions(opts ...Option) *Options {
	opt := &Options{}
	for _, o := range opts {
		o(opt)
	}
	return opt
}

func main() {
	// 使用默认参数创建Options对象
	opt1 := NewOptions()
	fmt.Println(opt1)  // &{ 0 0}

	// 使用WithName函数选项创建Options对象
	opt2 := NewOptions(WithName("Alice"))
	fmt.Println(opt2)  // &{Alice 0 0}

	// 使用WithAge和WithHeight函数选项创建Options对象
	opt3 := NewOptions(WithAge(18), WithHeight(1.65))
	fmt.Println(opt3)  // &{ 18 1.65}
}

In the example above, we have defined an Options type and three Option functions: WithName, WithAge, and WithHeight.

Each option function returns a function that takes an Options pointer as a parameter and can modify the corresponding fields of the Options object.

The NewOptions function takes a variable number of Option types as parameters, modifies the Options object based on the passed Option functions, and returns the modified Options object.

By utilizing the function options design pattern, we can selectively pass parameters as needed, making the code more flexible and easily expandable.