快捷導(dǎo)航

golang1.21泛型函數(shù)全面講解

更新時間：2023年09月04日 09:17:35 作者：洛天楓

在Go編程語言中,泛型一直是一個備受期待的特性,隨著Go?1.21的發(fā)布,本文旨在提供Go?1.21中泛型的詳細探索,闡明它們的優(yōu)點、語法、實現(xiàn)和最佳實踐,希望對大家有所幫助

Go 1.21中的泛型基本語法

要定義泛型函數(shù)或類型，可以使用類型 T關(guān)鍵字，后跟用方括號[]括起來的泛型形參的名稱。例如，要創(chuàng)建一個接受任意類型的slice并返回其第一個元素的泛型函數(shù)，可以這樣定義:

func First[T any](items []T) T {
    return items[0]
}

在上面的例子中，[T any]表示類型參數(shù)T，它表示任意類型。any關(guān)鍵字表示T類型可以是任何有效類型。

然后，可以使用任何切片類型調(diào)用First函數(shù)，該函數(shù)將返回該切片的第一個元素。例如:

func func1() {
	intSlice := []int{1, 2, 3, 4, 5}
	firstInt := First[int](intSlice) // returns 1
	println(firstInt)
	stringSlice := []string{"apple", "banana", "cherry"}
	firstString := First[string](stringSlice) // returns "apple"
	println(firstString)
}
func First[T any](items []T) T {
	return items[0]
}

注意，在調(diào)用泛型函數(shù)時，我們在方括號[]中指定類型參數(shù)。這允許編譯器在編譯期間為該類型生成特定的代碼。

我們還可以向泛型類型參數(shù)添加約束，將其限制為特定類型。例如，如果我們想將類型T限制為僅實現(xiàn)Stringer接口的類型，可以使用如下約束:

func PrintString[T Stringer](value T) {
    fmt.Println(value.String())
}

Stringer約束確保類型T必須具有String()方法。這個約束允許我們在函數(shù)的value參數(shù)上安全地調(diào)用String()方法。

在Go 1.21中具有各種類型的泛型

在另一個示例中，讓我們編寫函數(shù)SumGenerics，它對各種數(shù)字類型(如int、int16、int32、int64、int8、float32和float64)執(zhí)行加法操作。

func SumGenerics[T int | int16 | int32 | int64 | int8 | float32 | float64](a, b T) T {
    return a + b
}

讓我們看看如何利用這個泛型函數(shù):

func func2() {
	sumInt := SumGenerics[int](2, 3)
	sumFloat := SumGenerics[float32](2.5, 3.5)
	sumInt64 := SumGenerics[int64](10, 20)
	fmt.Println(sumInt)   // returns 5
	fmt.Println(sumFloat) // returns 6.0
	fmt.Println(sumInt64) // returns 30
}

在上面的代碼中，我們可以看到，通過在調(diào)用泛型函數(shù)時在方括號[]中指定類型參數(shù)，我們可以對不同的數(shù)字類型執(zhí)行加法操作。類型約束確保只有指定的類型[T int, int16, int32, int64, int8, float32，或float64]可以用作類型參數(shù)。

以這種方式使用泛型使我們能夠在不犧牲類型安全的情況下編寫簡潔且可重用的代碼?？梢允褂酶鞣N數(shù)字類型調(diào)用該函數(shù)，編譯器將為每種類型生成特定的代碼，以確保正確執(zhí)行加法操作。

Go 1.21中具有任意數(shù)據(jù)類型的泛型

泛型可以用于任意數(shù)據(jù)類型的序列化和反序列化，使用提供的序列化和反序列化函數(shù):

type Person struct {
 Name    string
 Age     int
 Address string
}
func Serialize[T any](data T) ([]byte, error) {
  buffer := bytes.Buffer{}
  encoder := gob.NewEncoder(&buffer)
  err := encoder.Encode(data)
  if err != nil {
    return nil, err
  }
  return buffer.Bytes(), nil
}
func Deserialize[T any](b []byte) (T, error) {
  buffer := bytes.Buffer{}
  buffer.Write(b)
  decoder := gob.NewDecoder(&buffer)
  var data T
  err := decoder.Decode(&data)
  if err != nil {
    return data, err
  }
  return data, nil
}

在本例中，我們有兩個通用函數(shù)Serialize和Deserialize，它們利用Go的gob包將任意數(shù)據(jù)類型轉(zhuǎn)換為字節(jié)，反之亦然。

func DeserializeUsage() {
  person := Person{
  Name:    "John",
  Age:     30,
  Address: "123 Main St.",
  }
  serialized, err := Serialize(person)
  if err != nil {
    panic(err)
  }
  deserialized, err := Deserialize[Person](serialized)
  if err != nil {
    panic(err)
  }
  fmt.Printf("Name: %s, Age: %d, Address: %s", deserialized.Name, deserialized.Age, deserialized.Address)
}

Output: Name: John, Age: 30, Address: 123 Main St.

在上面的代碼中，我們用一些數(shù)據(jù)創(chuàng)建了一個Person實例。然后使用Serialize函數(shù)將person對象轉(zhuǎn)換為字節(jié)數(shù)組。稍后，使用Deserialize函數(shù)，將字節(jié)數(shù)組轉(zhuǎn)換回Person對象。

通過將序列化和反序列化函數(shù)定義為具有T any類型參數(shù)的泛型函數(shù)，我們可以序列化和反序列化任何支持使用gob包進行編碼和解碼的數(shù)據(jù)類型。

在Go中使用泛型和Validate函數(shù)自定義驗證器

讓我們用自定義驗證器編寫一個通用的Validate函數(shù)。

type Validator[T any] func(T) error
func Validate[T any](data T, validators ...Validator[T]) error {
 for _, validator := range validators {
  err := validator(data)
  if err != nil {
   return err
  }
 }
 return nil
}

在本例中，我們有一個通用的Validate函數(shù)，它使用自定義驗證器執(zhí)行數(shù)據(jù)驗證。Validator類型表示一個函數(shù)，它接受任意類型T的值并返回一個錯誤。

func StringNotEmpty(s string) error {
 if len(strings.TrimSpace(s)) == 0 {
  return fmt.Errorf("string cannot be empty")
 }
 return nil
}
func IntInRange(num int, min, max int) error {
 if num < min || num > max {
  return fmt.Errorf("number must be between %d and %d", min, max)
 }
 return nil
}

此外，我們有兩個自定義驗證器示例:StringNotEmpty和IntInRange。

StringNotEmpty確保字符串不為空，IntInRange檢查整數(shù)是否在指定范圍內(nèi)。

package main
func main() {
  person := Person{
    Name:    "John",
    Age:     30,
    Address: "123 Main St.",
  }
  err := Validate(person, func(p Person) error {
    return StringNotEmpty(p.Name)
  }, func(p Person) error {
    return IntInRange(p.Age, 0, 120)
  })
  if err != nil {
    println(err.Error())
    panic(err)
  }
  println("Person is valid")
}

在本例中，我們創(chuàng)建了一個Person實例，并將其傳遞給Validate函數(shù)。我們?yōu)?code>Person結(jié)構(gòu)定義了兩個自定義驗證器，檢查Name字段是否為空，Age字段是否在有效范圍內(nèi)。如果任何驗證器返回錯誤，驗證過程將停止，并返回相應(yīng)的錯誤。

通過使用泛型和自定義驗證器，Validate函數(shù)允許跨不同數(shù)據(jù)類型進行靈活和可重用的數(shù)據(jù)驗證，增強代碼可重用性，并使添加或修改驗證規(guī)則變得容易。

讓我們再寫一個使用validator函數(shù)的例子

type LoginForm struct {
    Username string
    Password string
}
func (f *LoginForm) Validate() error {
    return Validate(f,
        func(l *LoginForm) error {
            return StringNotEmpty(l.Username)
        },
        func(l *LoginForm) error {
            return StringNotEmpty(l.Password)
        },
    )
}
func ValidateUsage2() {
    loginForm := LoginForm{
        Username: "John",
        Password: "123",
    }
    err := loginForm.Validate()
    if err != nil {
        println(err.Error())
        panic(err)
    }
    println("Login form is valid")
}

在本例中，LoginForm結(jié)構(gòu)實現(xiàn)了一個Validate方法，該方法利用了我們之前定義的Validate泛型函數(shù)。

Validate方法調(diào)用通用的Validate函數(shù)，并為它提供兩個特定于LoginForm類型的自定義驗證器。驗證器表示為閉包函數(shù)，使用StringNotEmpty驗證器函數(shù)檢查Username和Password字段是否為空。

要驗證LoginForm實例，只需在實例本身上調(diào)用validate方法。

package main
func main() {
  loginForm := LoginForm{
    Username: "John",
    Password: "123",
  }
  err := loginForm.Validate()
  if err != nil {
    println(err.Error())
    panic(err)
  }
  println("Login form is valid")
}

如果任何驗證器返回錯誤，驗證過程將停止，并返回相應(yīng)的錯誤。在這種情況下，我們相應(yīng)地處理錯誤。