简单的Golang泛型教程

函数和方法的泛型声明#

在Golang 1.17之前，Golang的函数和方法中只支持使用具体类型进行声明，在函数内部也都只能使用特定类型的变量或参数。而引入泛型之后，Golang的函数和方法中就可以使用泛型类型进行声明了。

1
func 函数名[T any](参数列表) 返回值类型 {
2
    // 函数体
3
}

1
func Swap[T any](a, b *T) {
2
    *a, *b = *b, *a
3
}
4

5
func main() {
6
    // 使用泛型函数
7
    a := 1
8
    b := 2
9
    Swap(&a, &b)
10
    fmt.Println(a, b)
11
}

1
func (接收者类型) 方法名[T any](参数列表) 返回值类型 {
2
    // 函数体
3
}

1
type Stack[T any] []T
2

3
func (s *Stack[T]) Push(v T) {
4
    *s = append(*s, v)
5
}
6

7
func (s *Stack[T]) Pop() T {
8
    index := len(*s) - 1
9
    res := (*s)[index]
10
    *s = (*s)[:index]
11
    return res
12
}
13

14
func main() {
15
    // 使用泛型方法
16
    var s Stack[int]
17
    s.Push(1)
18
    s.Push(2)
19
    s.Push(3)
20
    fmt.Println(s.Pop())
21
    fmt.Println(s.Pop())
22
}

接口的泛型声明#

在Golang 1.17后，我们还可以使用泛型类型来声明接口。在这种情况下，我们可以使用type关键字来定义一个代表任意类型的泛型类型，并且在接口中使用该类型来进行声明。

下面是一个示例代码，演示了如何在接口中使用泛型：

1
type Container[T any] interface {
2
    Get() T
3
    Put(v T)
4
}
5

6
type Stack[T any] []T
7

8
func (s *Stack[T]) Push(v T) {
9
    *s = append(*s, v)
10
}
11

12
func (s *Stack[T]) Pop() T {
13
    index := len(*s) - 1
14
    res := (*s)[index]
15
    *s = (*s)[:index]
16
    return res
17
}
18

19
func (s *Stack[T]) Get() T {
20
    return s.Pop()
21
}
22

23
func (s *Stack[T]) Put(v T) {
24
    s.Push(v)
25
}
26

27
func main() {
28
    // 使用泛型接口
29
    var c Container[int] = new(Stack[int])
30
    c.Put(1)
31
    c.Put(2)
32
    fmt.Println(c.Get())
33
    fmt.Println(c.Get())
34
}

这段代码中，我们声明了一个名为Container的泛型接口，并且在其中声明了Get和Put两个方法，这两个方法都使用了T作为自己的泛型类型。而在Stack类型的实现中，我们同样实现了Get和Put方法，并且额外声明了一个方法Pop，用于从栈中获取元素。在实际使用中，我们通过Container[int]声明了一个类型为int的容器，并且使用Stack[int]实现了该容器。

结构体和嵌入的泛型#

在Golang 1.17后，我们还可以在结构体和嵌入中使用泛型类型进行声明。这种情况下，我们可以使用与函数和方法类似的语法进行声明。

下面是一个示例代码，演示了如何在结构体和嵌入中使用泛型：

1
type Pair[T any] struct {
2
    first T
3
    second T
4
}
5

6
type IntPair struct {
7
    Pair[int]
8
}
9

10
func main() {
11
    // 使用结构体和嵌入的泛型
12
    p := IntPair{Pair[int]{1, 2}}
13
    fmt.Println(p.first, p.second)
14
}

这段代码中，我们声明了一个名为Pair的泛型结构体，并且定义了一个包含两个成员变量first和second的结构体。在IntPair类型的定义中，我们嵌入了Pair[int]，使得IntPair类型包含了两个类型为int的成员变量。在实际使用中，我们通过IntPair{Pair[int]{1, 2}}来创建一个类型为IntPair的变量p，并且获取了其中的两个成员变量。

总结#

到此为止，我们已经讲解了在Golang 1.17中泛型的主要应用场景，包括函数、方法、接口、结构体和嵌入。在实际开发中，我们可以使用这些泛型来提高程序的可扩展性和可重用性，从而让程序更加灵活和具有适应性。如果您还没有尝试过使用Golang中的泛型，那么不妨在接下来的代码中尝试一下吧！