type User struct {
	Name string
	Age  int
	Tags map[string]string
}

// UserOption 第一种写法,函数写法
type UserOption func(u *User)

func WithName(name string) UserOption {
	return func(u *User) {
		u.Name = name
	}
}

func WithAge(age int) UserOption {
	return func(u *User) {
		u.Age = age
	}
}

func WithTag(k, v string) UserOption {
	return func(u *User) {
		if u.Tags == nil {
			u.Tags = make(map[string]string)
		}
		u.Tags[k] = v
	}
}

// 默认用户实现
func DefaultUser() *User {
	return &User{
		Name: uuid.NewString(),
		Age:  0,
	}
}

func NewUser(options ...UserOption) *User {
	// 这里还可以加一个默认user实现,用于用户不进行任何option的
	defaultUser := DefaultUser()
	// 遍历的时候直接对defaultUser进行修改
	//user := &User{}
	// 遍历函数的时候就已经执行了
	for _, option := range options {
		// 这个option其实就是WithName和WithAge的返回值
		// 也就是UseOption这个函数
		// 所以需要参数*User
		option(defaultUser)
	}
	return defaultUser
}

func main() {
	// 使用函数写法定义的 option 模式
	user := NewUser(WithName("Sakura"), WithAge(20), WithTag("k1", "v1"))
	fmt.Println(user)
	// 不传入任何 option 的 user
	user2 := NewUser()
	fmt.Print(user2)
}

type User struct {
	Name string
	Age  int
	Tags map[string]string
}

// UserOption 接口形式定义 UserOption
type UserOption interface {
	apply(*User)
}

// 如果是基本数据类型,直接在自定义类型就行
// 也可以定义为结构体
type nameOption string

func (n nameOption) apply(userOption *User) {
	userOption.Name = string(n)
}

// 如果是复杂数据类型,需要定义一个结构体,然后实现接口方法
// 假设 ageOption 是一个包含多个配置的结构体
type ageOption struct {
	age int
}

func (a ageOption) apply(userOption *User) {
	userOption.Age = a.age
}

type tagOption struct {
	k string
	v string
}

func (t tagOption) apply(userOption *User) {
	if userOption.Tags == nil {
		userOption.Tags = make(map[string]string)
	}
	userOption.Tags[t.k] = t.v
}

func WithName(name string) UserOption {
	return nameOption(name)
}

func WithAge(age int) UserOption {
	return ageOption{age: age}
}

func WithTag(key, value string) UserOption {
	return tagOption{k: key, v: value}
}


func DefaultUser() *User {
	return &User{
		Name: "default", // 或者uuid.String
		Age:  18,
		Tags: make(map[string]string),
	}
}

func NewUser(opts ...UserOption) *User {
	user := DefaultUser()
	
	for _, opt := range opts {
		opt.apply(user)
	}

	return user
}

func TestNewUser(t *testing.T) {
	user := NewUser(WithAge(18), WithName("Sakura"), WithTag("tag", "value"))
	fmt.Println(user)
	user2 := NewUser()
	fmt.Println(user2)
}

虽然接口形式比函数形式写法上复杂了不少，但也多了许多优点

• 可比较性

假设我们想要比较两个 UserOption 是否相同。在接口形式下，可以通过实现一个方法来比较它们。

type nameOption struct {
	name string
}

func (n nameOption) apply(opts *UserOptions) {
	opts.Name = n.name
}

// 新增一个方法用于比较两个 nameOption 是否相等
func (n nameOption) isEqual(other UserOption) bool {
	if no, ok := other.(nameOption); ok {
		return n.name == no.name
	}
	return false
}

• 可读性和可调试性

可以让 UserOption 实现 fmt.Stringer 接口

import "fmt"

// UserOption 接口形式定义 UserOption
type UserOption interface {
	apply(*User)
	// String 实现 fmt.Stringer 接口
	String() string
}

// 实现 fmt.Stringer 接口
func (n nameOption) String() string {
	return fmt.Sprintf("nameOption{name: %s}", n.name)
}

func (a ageOption) String() string {
	return fmt.Sprintf("ageOption{age: %d}", a.age)
}

func (t tagOption) String() string {
	return fmt.Sprintf("tagOption{key: %s, value: %s}", t.key, t.value)
}

• 可拓展性

还可以为 UserOption 添加更多行为。例如，可以添加一个 Validate 方法来检查 Option 是否有效。

// 为 UserOption 添加 Validate 方法
type UserOption interface {
	apply(*UserOptions)
	// 可选：实现 String() 方法
	String() string
	// 可选：实现 Validate() 方法
	Validate() error
}

func (n nameOption) Validate() error {
	if len(n.name) == 0 {
		return fmt.Errorf("name cannot be empty")
	}
	return nil
}

func (a ageOption) Validate() error {
	if a.age < 0 {
		return fmt.Errorf("age cannot be negative")
	}
	return nil
}

func (t tagOption) Validate() error {
	if len(t.key) == 0 || len(t.value) == 0 {
		return fmt.Errorf("tag key and value cannot be empty")
	}
	return nil
}

在初始化 User 的时候检查传入参数的合法性

func NewUser(opts ...UserOption) （*User,error) {
	user := DefaultUser()
	
	for _, opt := range opts {
        // 检查完是否合法之后，再进行 apply
		err := opt.Validate()
		if err != nil {
			return nil, err
		}
		opt.apply(user)
	}
	return user,nil
}