Go 构建对象模式

Function Option 是一种通过函数选项来配置函数参数的方式。通过在函数中定义多个接受选项参数的函数，可以根据需要选择性地传递这些选项，而不是像传统方式那样传递一长串参数。这样可以使函数调用更清晰易读，避免参数传递顺序混乱的问题。

Builder 模式则是一种用于构建复杂对象的设计模式。在 Go 中，Builder 通常通过链式调用一系列方法来构建对象，并在最后通过一个构建方法返回所需的对象实例。这种方式可以让我们以一种流畅的方式来构建对象，同时也可以灵活地添加或修改构建过程中的步骤。

Function Option 更适合于需要配置多个参数的函数，而 Builder 更适合于需要构建复杂对象的情况。两者都能提高代码的可读性和灵活性，使得代码更易于维护和扩展。

简单的构造函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type Option struct {
	A string
	B string
	C int
}
func newOption(a, b string, c int) *Option {
	return &Option{
		A: a,
		B: b,
		C: c,
	}
}

function option

场景： 1、我们可能需要为Option的字段指定默认值 2、Option的字段成员可能会发生变更

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

type OptionFunc func(*Option)

func WithA(a string) OptionFunc {
	return func(o *Option) {
		o.A = a
	}
}

func WithB(b string) OptionFunc {
	return func(o *Option) {
		o.B = b
	}
}

func WithC(c int) OptionFunc {
	return func(o *Option) {
		o.C = c
	}
}

var (
	defaultOption = &Option{
		A: "A",
		B: "B",
		C: 100,
	}
)

func newOption(opts ...OptionFunc) (opt *Option) {
	opt = defaultOption
	for _, o := range opts {
		o(opt)
	}
	return
}

builder

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

type Builder struct {
	opt *Option
}

func NewBuilder() *Builder {
	return &Builder{
		opt: &Option{},
	}
}

func (b *Builder) WithA(a string) *Builder {
	b.opt.A = a
	return b
}

func (b *Builder) WithB(b2 string) *Builder {
	b.opt.B = b2
	return b
}

func (b *Builder) WithC(c int) *Builder {
	b.opt.C = c
	return b
}

func (b *Builder) Build() *Option {
	return b.opt
}

builder := NewBuilder()
option := builder.WithA("new A").WithB("new B").WithC(200).Build()
fmt.Printf("%+v\n", option)