如何为Go函数设置多组Options列表？解决配置复用问题

Go语言不允许函数存在多个可变参数（...T），这是导致Bar函数编译报错的直接原因。要在不合并fooOptions和barOptions的前提下复用代码，推荐以下两种方案：

方案一：为Bar构建包含Foo选项的配置结构（推荐） #

这种方式既保留了Options模式的优雅调用体验，又能直接复用Foo的配置方法，无需重复编写WithXXX函数。

type fooOptions struct {
    fooName string
}

type FooOptions func(*fooOptions)

func WithFooName(fooName string) FooOptions {
    return func(options *fooOptions) {
        options.fooName = fooName
    }
}

func Foo(options ...FooOptions) {
    opts := &fooOptions{}
    for _, opt := range options {
        opt(opts)
    }
    // 执行Foo的业务逻辑
}

// 重新定义Bar的配置结构，包含自身选项和Foo的选项切片
type BarOptions struct {
    barName string
    fooOpts []FooOptions
}

// Bar的配置函数类型
type BarOption func(*BarOptions)

func WithBarName(barName string) BarOption {
    return func(options *BarOptions) {
        options.barName = barName
    }
}

// 包装Foo的配置函数，适配BarOption类型
func WithFooOpt(opt FooOptions) BarOption {
    return func(options *BarOptions) {
        options.fooOpts = append(options.fooOpts, opt)
    }
}

func Bar(options ...BarOption) {
    opts := &BarOptions{}
    for _, opt := range options {
        opt(opts)
    }

    // 执行Bar的业务逻辑
    // 调用Foo并传入复用的配置
    Foo(opts.fooOpts...)
}

// 调用示例
func main() {
    Bar(
        WithBarName("customBar"),
        WithFooOpt(WithFooName("customFoo")),
    )
}

方案二：将Foo选项作为切片参数传入 #

这种方式更直接，但调用时需要手动将Foo的配置函数打包成切片，灵活性稍差：

// 保留原有的fooOptions、FooOptions、WithFooName、Foo实现不变
// 保留原有的barOptions、BarOptions、WithBarName实现不变

// 修改Bar函数，将FooOptions作为切片参数（可变参数只能放在最后）
func Bar(fooOpts []FooOptions, boptions ...BarOptions) {
    bopts := &barOptions{}
    for _, opt := range boptions {
        opt(bopts)
    }
    // 调用Foo
    Foo(fooOpts...)
}

// 调用示例
func main() {
    Bar(
        []FooOptions{WithFooName("customFoo")},
        WithBarName("customBar"),
    )
}

方案对比 #

• 方案一：调用体验更符合Options模式的习惯，类型安全，且能灵活扩展更多关联配置，是更优的选择。
• 方案二：代码改动最小，但调用时需要手动处理切片，不够优雅，适合快速临时解决问题。

内容的提问来源于stack exchange，提问作者LoremIpsum