泛型

从1.18版本开始，Go添加了对泛型的支持，即类型参数

泛型函数

package main

import "fmt"

// 定义一个泛型函数,用于交换两个值
func Swap[T any](a, b *T) {
    *a, *b = *b, *a
}

func main() {
    // 交换两个整数
    x, y := 1, 2
    fmt.Printf("x=%d, y=%d\n", x, y)
    Swap(&x, &y)
    fmt.Printf("x=%d, y=%d\n", x, y)

    // 交换两个字符串
    a, b := "hello", "world"
    fmt.Printf("a=%s, b=%s\n", a, b)
    Swap(&a, &b)
    fmt.Printf("a=%s, b=%s\n", a, b)
}

泛型函数约束

package main

import "fmt"

type Constraint interface {
    int | float64 | string // | []int
}

func Printer[T Constraint](vals ...T) {
    for _, v := range vals {
        fmt.Printf("%v ", v)
    }
    fmt.Println()
}

func main() {
    Printer(1, 2, 3)
    Printer(1.1, 2.2, 3.3)
    Printer("a", "b", "c")
    // Printer([]int{1,2}, []int{5, 6}, []int{8, 9})
}

泛型结构体

package main

import "fmt"

// 定义一个泛型结构体
type Stack[T any] struct {
    data []T
}

// 为结构体定义Push方法
func (s *Stack[T]) Push(v T) {
    s.data = append(s.data, v)
}

// 为结构体定义Pop方法
func (s *Stack[T]) Pop() T {
    if len(s.data) == 0 {
        var zero T
        return zero
    }
    v := s.data[len(s.data)-1]
    s.data = s.data[:len(s.data)-1]
    return v
}

func main() {
    // 创建一个整数Stack
    intStack := Stack[int]{}
    intStack.Push(1)
    intStack.Push(2)
    intStack.Push(3)
    fmt.Println(intStack.Pop()) // 输出: 3
    fmt.Println(intStack.Pop()) // 输出: 2

    // 创建一个字符串Stack
    stringStack := Stack[string]{}
    stringStack.Push("hello")
    stringStack.Push("world")
    fmt.Println(stringStack.Pop()) // 输出: world
    fmt.Println(stringStack.Pop()) // 输出: hello
}

泛型切片

package main

type MySlice[T any] []T

func main() {
  var mySlice MySlice[string]
  mySlice = append(mySlice, "阿哲")
  var intSlice MySlice[int]
  intSlice = append(intSlice, 2)
}

泛型map

package main

import "fmt"

type MyMap[K string | int, V any] map[K]V

func main() {
  var myMap = make(MyMap[string, string])
  myMap["name"] = "阿哲"
  fmt.Println(myMap)
}