Go 泛型提前尝试

Yusank 收录于 Go

2021-12-09 约 1836 字预计阅读 4 分钟

Go 已经确实在 1.18 版本支持泛型了，预计 2022 年 2 月份发布 1.18 正式版，到目前为止泛型相关规范已确定且可以在开发分支的 go 版本中尝试使用了，这篇文章带你领略 go 的泛型.

安装 go 开发版

没有发版我怎么提前尝试呢？

在这里分享一个小技巧，学会了之后以后每个新版本发布前都可以提前尝试新版的特性，提前学习好。

可以通过下面的命令安装最新的 master 分支：

1
2


go install golang.org/dl/gotip
gotip download

现在可以把 gotip 这个命令当做 go 命令来使用了，

1
2
3


gotip version

go version devel go1.18-d6c4583 Wed Dec 8 23:38:20 2021 +0000 linux/amd64

灵活使用 bash alias

gotip 敲起来麻烦，总是习惯性打 go build/run , 我就在 .bashrc 添加了一行配置

1
2


alias go18="gotip"
# 如果你有单独的 workspace 直接用 go="gotip" 也可以

泛型

基础用法

终于可以不用为 int/uint/int8/int16/int32/int64 写一堆代码类似的代码了！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


type Integer interface{
    ~uint|~uint8|~uint16|~uint32|~uint64|~int|~int8|~int16|~int32|~int64
}

func Max[T Integer](a, b T) T {
    if a > b {
        return a
    }

    return b
}

func main() {
    fmt.Println(Max(1, 2)) // 2
    fmt.Println(Max(uint(1), uint(2))) // uint(2)
    fmt.Println(Max(int64(1), int64(2))) // 2
}

定义支持的类型 Integer, | 表示并集， ~ 表示底层是该类型也可以(type CustomInt int 这种情况)。这个就是最基础的基于泛型的代码了，是不是看着都不太像 go 代码了，哈哈。

其实， Integer 类型不需要我们定义了，go 官方新增了 constraints 包，放了一些常用的泛型类型，后期应该也会扩展。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package constraints defines a set of useful constraints to be used
// with type parameters.
package constraints

// Signed is a constraint that permits any signed integer type.
// If future releases of Go add new predeclared signed integer types,
// this constraint will be modified to include them.
type Signed interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

// Unsigned is a constraint that permits any unsigned integer type.
// If future releases of Go add new predeclared unsigned integer types,
// this constraint will be modified to include them.
type Unsigned interface {
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

// Integer is a constraint that permits any integer type.
// If future releases of Go add new predeclared integer types,
// this constraint will be modified to include them.
type Integer interface {
    Signed | Unsigned
}

// Float is a constraint that permits any floating-point type.
// If future releases of Go add new predeclared floating-point types,
// this constraint will be modified to include them.
type Float interface {
    ~float32 | ~float64
}

// Complex is a constraint that permits any complex numeric type.
// If future releases of Go add new predeclared complex numeric types,
// this constraint will be modified to include them.
type Complex interface {
    ~complex64 | ~complex128
}

// Ordered is a constraint that permits any ordered type: any type
// that supports the operators < <= >= >.
// If future releases of Go add new ordered types,
// this constraint will be modified to include them.
type Ordered interface {
    Integer | Float | ~string
}

上面的代码可以简化为如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


import (
    "constraints"
)

func Max[T constraints.Integer](a, b T) T {
    if a > b {
        return a
    }

    return b
}

func main() {
    fmt.Println(Max(1, 2)) // 2
    fmt.Println(Max(uint(1), uint(2))) // uint(2)
    fmt.Println(Max(int64(1), int64(2))) // 2
}

当然如果想扩展也是完全可以，比如上面的 Max 方法要支持 float 类型的话，自己定义一个新的 interface 即可。

1
2
3


type Number interface{
    constraints.Integer | constraints.Float
}

花式玩法

slice

如果你写 go 的时间长的话，应该经历过写很多长得很像排序算法，也应该羡慕过python/js的直接 string.sort()这种写法的，现在用泛型也可以玩出同样的姿势了。废话不多说直接上货：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


type Slice[T constraints.Ordered] []T

func (s Slice[T]) Sort() {
    sort.Slice(s,func (i,j int)  bool {
        return s[i] < s[j]
    })
}

func main() {
    // 随时定义随时调用，没有过多的方法调用或者额外的条件判断了
    ss := Slice[string]{"b","d","c","a"}
    ss.Sort()
    fmt.Println(ss)
    
    is := Slice[int]{2,4,1,3}
    is.Sort()
    fmt.Println(is)
}

这块代码运行成功后，我反正是很爽的，以后起码少些很多长得像功能还一样的代码了，等正式发版后可以搞一波支持泛型的基础库了。

map

map 的 key-value 均可以指定泛型，从而灵活的做一些处理，下面以返回某个 map 的 key 作为数组的例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 定义一个 key 可以做对比的类型 value 作为任意类型
// 注： any == interface{}
type Map[K constraints.Ordered, V any] map[K]V

func (m Map[K,V]) Keys() []K {
    var result []K
    for k := range m {
        result = append(result, k)
    }

    return result
}

func main() {
    sm := Map[string,int]{"a":1,"b":2}
    fmt.Println(sm.Keys()) // [a, b]

    im := Map[int,string]{1:"a",2:"b"}
    fmt.Println(im.Keys()) // [1, 2]
}

这样减少了很多类型判断类型转换的过程了，只要初始化的时候声明好了后返回的就是对应类型的数组而不是 []interface{} .

chan

chan 作为在高并发异步编程中非常常用的特性，之前也面领着同样类型转换类型判断的困扰，设想一个场景，如果我有个需求，将数组转换成 channel，异步的去处理这组数据，如果数组类型是单个还好如果我又有 string 的又有 int 的未来可能还会有别的类型，那只能一个类型一个方法或者统一 interface 然后使用时类型转换。如果用泛型实现呢？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 类型也可以按需求限制在 Ordered 或 comparable 等范围
func convertChan[T any](slice []T) chan T {
    ch := make(chan T, 1)
    go func() {
        defer close(ch)
        for _, v := range slice {
            ch <- v
        }
    }()

    return ch
}

func main() {
    s1 := []string{"a", "b", "c"}
    // s2 := []float64{1.1, 1.2, 1.3}
    ch := convertChan(s1)
    // ch => chan string
    for v := range ch {
        fmt.Println(v)
    }
    // a, b, c
}

总结

整体而言，新增的泛型我觉得利大于弊的，看起来是语法复杂了很多其实并没有，定义的时候限制一些可用的基础类型或者直接用 any 来表示接受任何类型的参数即可。

对于开发者来说绝对会减少一部分重复代码的，也可以做一些更好的抽象，从长远来说对开发者还是好处很多的。

1.18是第一个支持泛型的版本，肯定会谨慎一些，之后的版本该功能说不定会得到更多的扩展和支持，所以还是很期待的。

最后

如果你对泛型有自己不一样的看法或者用法，也可以来讨论讨论。

目录

Go 泛型提前尝试

安装 go 开发版

泛型

基础用法

花式玩法

slice

map

chan

总结

参考文档