1
// 没有泛型：每种类型都要写一遍
2
func SumInts(a []int) int { ... }
3
func SumFloats(a []float64) float64 { ... }
4

5
// 有泛型：一套代码处理所有类型
6
func Sum[T any](a []T) T { ... }

1
// 泛型带来的复杂性
2
type Container[T any] struct {
3
    items []T
4
}
5

6
func (c *Container[T]) Get() T { ... }
7

8
// 接口泛型
9
type Adder[T any] interface {
10
    Add(T, T) T
11
}

1
// 使用空接口
2
type Any interface{}
3

4
func SumAny(a []Any) Any {
5
    var sum Any
6
    for _, v := range a {
7
        // 类型断言
8
        switch v := v.(type) {
9
        case int:
10
            sum = sum.(int) + v
11
        case float64:
12
            sum = sum.(float64) + v
13
        }
14
    }
15
    return sum
16
}

1
// 生成器生成具体类型版本
2
//go:generate stringer -type=Command
3

4
// 生成后
5
type Command int
6
const (
7
    CmdStart Command = iota
8
    CmdStop
9
    CmdRestart
10
)

1
import "reflect"
2

3
func DeepCopy(src interface{}) interface{} {
4
    return reflect.DeepClone(src)
5
}

1
// Go 的核心创新：goroutine + channel
2
func worker() {
3
    ch := make(chan int)
4
    go func() {
5
        ch <- 42
6
    }()
7
    result := <-ch
8
}

1
// 每次都要自己写
2
func MapInts(in []int, f func(int) int) []int {
3
    out := make([]int, len(in))
4
    for i, v := range in {
5
        out[i] = f(v)
6
    }
7
    return out
8
}
9

10
// 无法写成通用的 Map

1
// Go 1.0 时代的 "官方" 做法
2
type IntList struct {
3
    data []int
4
}
5

6
type StringList struct {
7
    data []string
8
}
9

10
// 大量重复代码

1
// 类型参数
2
func Map[T any](slice []T, fn func(T) T) []T {
3
    result := make([]T, len(slice))
4
    for i, v := range slice {
5
        result[i] = fn(v)
6
    }
7
    return result
8
}
9

10
// 使用
11
numbers := []int{1, 2, 3}
12
doubled := Map(numbers, func(n int) int { return n * 2 })

1
// 使用约束限制类型
2
type Addable interface {
3
    int | int8 | int16 | int32 | int64 |
4
          float32 | float64
5
}
6

7
func Sum[T Addable](a []T) T {
8
    var sum T
9
    for _, v := range a {
10
        sum += v
11
    }
12
    return sum
13
}

1
// 标准库新增的泛型容器
2
type Set[T comparable] struct {
3
    items map[T]struct{}
4
}
5

6
// 使用
7
strings := Set[string]{}
8
strings.Add("hello")

1
2019: Go 2 提案开始讨论泛型
2
2020: Go 1.17 实验性泛型
3
2021: Go 1.18 正式发布泛型