Golang函數式選項模式怎么實現

本篇內容主要講解“Golang函數式選項模式怎么實現”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Golang函數式選項模式怎么實現”吧!

概覽

最近閱讀源碼的時候看到一段不錯的代碼，但是當時卻不是非常理解為什么這么寫。
我們先來看一下源代碼：

type User struct {
	ID     string
	Name   string
	Age    int
	Email  string
	Phone  string
	Gender string
}

type Option func(*User)

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

func WithEmail(email string) Option {
	return func(u *User) {
		u.Email = email
	}
}

func WithPhone(phone string) Option {
	return func(u *User) {
		u.Phone = phone
	}
}

func WithGender(gender string) Option {
	return func(u *User) {
		u.Gender = gender
	}
}

func NewUser(id string, name string, options ...func(*User)) (*User, error) {
	user := User{
		ID:     id,
		Name:   name,
		Age:    0,
		Email:  "",
		Phone:  "",
		Gender: "female",
	}
	for _, option := range options {
		option(&user)
	}
	//...
	return &user, nil
}

func main() {
	user, err := NewUser("1", "Ada", WithAge(18), WithPhone("123456"))
	if err != nil {
		fmt.Printf("NewUser: err:%v", err)
	}
	fmt.Printf("NewUser Success")
}

當時呢，也不是很明白 NewUser 這個構造函數為什么要這么寫，后來查看了資料才知道了這是一種設計模式–函數式選項(functional options)模式。

什么是函數式選項模式，為什么要這么寫，這個編程模式解決了什么問題呢？

其實就是為了解決動態靈活的配置不同的參數的問題。

假如我們有一個需求：
在網站注冊賬號，有很多可選的選項，可填可不填。會根據你填的信息初始化你的 User 對象。

重載函數

如果你有 C++ 或者 Java 的編程基礎，你的第一反應應該是函數重載。

但是因為 Golang 語言不像 C++ 一樣支持重載函數，所以，你得用不同的函數名來應對不同的配置選項。

像這樣：

func NewUserDefault(id string, name string) (*User, error) {
  return &User{ID: id, Name: name}, nil
}

func NewUserWithPhone(id string, name string, phone string) (*User, error) {
  return &User{ID: id, Name: name, Phone: phone}, nil
}

func NewUserWithEmail(id string, name string, email string) (*User, error) {
  return &User{ID: id, Name: name, Email: email}, nil
}

如果一共只有兩三個參數的情況下，比較簡單，但是更多的選項的組合就代碼看起來很亂了。

配置化

這個時候我們可能會想到，配置化。
把所有可選的參數放到一個Config的struct中。

type Config struct {
    Age    int
    Email  string
    Phone  string
    Gender string
}

然后把Config放到User的struct中。

type User struct {
    ID   string
    Name string
    Conf *Config
}

于是，我們只需要一個 NewUser() 的函數了，在使用前需要構造 Config 對象。

func NewUser(id string, name string, conf *Config) (*User, error) {
    //...
}
//Using the default configuratrion
user, _ := NewUser("1", "Ada", nil)

conf := Config{Age:18, Phone: "123456"}
user2, _ := NewUser("2", "Bob", &conf)

這段代碼看起來算是不錯了，很多時候我使用的一些開源庫也是這么寫的。通過引入一個Config對象來解決多個參數的組合的問題。

Builder模式

有些經常使用Java的同學會想到Builder模式。

于是就可以以如下的方式來使用了:

user := new(UserBuilder).Create("1", "Ada").
  age(18).
  phone("123456").
  gender("female").
  Build()

需要引入一個抽象的UserBuilder對象，來包裝User對象，最終Build一個User對象返回。

函數式選項模式

函數式選項模式 首先需要定義一個函數類型：

type Option func(*User)

然后，我們定義一組返回函數的函數：

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

func WithEmail(email string) Option {
	return func(u *User) {
		u.Email = email
	}
}

func WithPhone(phone string) Option {
	return func(u *User) {
		u.Phone = phone
	}
}

func WithGender(gender string) Option {
	return func(u *User) {
		u.Gender = gender
	}
}

這個模式和Builder模式的區別是，Builder模式返回的是 * User 對象，Functional Options 返回的是函數類型 func(* User)。

上面這組代碼傳入一個參數，然后返回一個函數，返回的這個函數會設置自己的 User 參數。

這樣我們就方便在 NewUser 里面統一初始化。循環對我們的函數類型執行調用操作。 option(&user)

func NewUser(id string, name string, options ...func(*User)) (*User, error) {
	user := User{
		ID:     id,
		Name:   name,
		Age:    0,
		Email:  "",
		Phone:  "",
		Gender: "female",
	}
	for _, option := range options {
		option(&user)
	}
	//...
	return &user, nil
}

調用方式如下：

user1, err := NewUser("1", "Ada")
user2, err := NewUser("2", "Bob", WithPhone("123456"), WithGender("male"))

這個看起來比較整潔和優雅，對外的接口只有一個NewUser。

相比于Builder模式，不需要引入一個Builder對象。

對比配置化的模式，也不需要引入一個新的Config。

到此，相信大家對“Golang函數式選項模式怎么實現”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！