796 字

4 分钟

【Golang】1.18泛型初步理解

2022-04-18

2022-04-29

Golang笔记

Golang

浏览量加载中...

0x00#

这次golang正式更新了泛型（之前的1.17 和1.18 Beta 1 中的只是测试版，其中有一些用法和正式版有较大的差别），是一次重大的更新，原以为在GO2.0的时候更新。

0x01 类型形参（Type Parameters）#

在之前想要实现一些通用的功能还是比较麻烦的，而且代码冗余。

比如实现gorm添加json类型字段：

1
type Table struct {
2
  AField    A
3
  BField    B
4
}
5

6
type A struct {
7
    AText string
8
}
9
func (A) GormDataType() string {
10
    return "json"
11
}
12
func (a *A) Scan(value interface{}) error {
13
    return json.Unmarshal(value.([]byte), a)
14
}
15
func (a A) Value() (value driver.Value, err error) {
16
    src, err := json.Marshal(a)
17
    return string(src), err
18
}
19

20
type B struct {
21
    BText string
22
}
23
func (B) GormDataType() string {
24
    return "json"
25
}
26
func (b *B) Scan(value interface{}) error {
27
    return json.Unmarshal(value.([]byte), b)
28
}
29
func (b B) Value() (value driver.Value, err error) {
30
    src, err := json.Marshal(b)
31
    return string(src), err
32
}

可以看到A和B中的GormDataType Scan Value方法几乎都是重复的，假如再添加C D那么就要添加6个重复发方法。

而golang 1.8开始正式支持泛型，那么利用泛型可以降低这样的代码冗余

使用泛型再次实现上述内容：

1
type Table struct {
2
  AField    JSON[A]
3
  BField    JSON[B]
4
}
5

6
type A struct {
7
  AText string
8
}
9

10
type B struct {
11
  BText string
12
}
13

14

15
type JSON[T any] struct {
16
    Data T
17
}
18
func (JSON[T]) GormDataType() string {
19
    return "json"
20
}
21
func (m *JSON[T]) Scan(value interface{}) error {
22
    return json.Unmarshal(value.([]byte), &m.Data)
23
}
24
func (m JSON[T]) Value() (value driver.Value, err error) {
25
    src, err := json.Marshal(m.Data)
26
    return string(src), err
27
}

可以看到我这里定义了一个JSON[T any]的类型专门处理json类型，此后添加C D字段就只需要定义相关的结构体并且添加JSON[C] JSON[D]即可。

其中any类型也是这次更新后的新类型字段，但any其实就是interface类型的别称

源码：

1
// src/builtin/builtin.go 95行
2

3
// any is an alias for interface{} and is equivalent to interface{} in all ways.
4
type any = interface{}

个人感觉any相比interface在传参等场合更直观

比如：

1
func Println(v ...any){}
2

3
func Println(v ...interface){}

当然，在定义接口时还是得用interface字段

判断类型#

1
func (m *JSON[T]) Test() {
2
    switch any(m.Data).(type) {
3
      case A:
4
        fmt.Println("A")
5
      case B:
6
        fmt.Println("B")
7
    }
8
}

#1014950980

0x02 类型集合（Type Sets）#

类型集合允许定义一个类型具有不同类型的集合

例如：

1
type Test interface {
2
  int|float64
3
}

定义了一个Test类型，表示为int float64类型的集合

如果不用泛型那怎么写呢

不使用泛型：

1
func Add(a, b interface{}) interface{} {
2
    switch a.(type) {
3
    case int:
4
        return a.(int)+b.(int)
5
    case float64:
6
        return a.(float64)+b.(float64)
7
    }
8
    return 0
9
}

使用泛型：

1
func Add[T int | float64](a, b T) T {
2
    return a + b
3
}

这样一对比使用泛型就简洁多了

应用：

1
type Num interface {
2
    int | int64 | int32 |
3
        float64 | float32 |
4
        uint | uint8 | uint16 | uint64
5
}
6

7
func Add[T Num](a, b T) T {
8
    return a + b
9
}
10

11
func Sub[T Num](a, b T) T {
12
    return a - b
13
}

0x03 类型约束#

1
type T interface {
2
  int | float64 | ~string
3
}

其中的~string表示定义的T类型集合也支持底层类型是string的类型

比如：

1
type A interface {
2
  ~string
3
}
4

5
func Splic[T A](a, b T) T {
6
  return a + b
7
}
8

9
var BString string
10

11
func main() {
12
  var a string = "a"
13
  var b BString = "b"
14

15
  Splic(a, b)
16
}

其中BString是自定义的一个底层为string的类型，如果没有加~的话会报错

支持与分享

如果这篇文章对你有帮助，欢迎分享给更多人或打赏支持！

打赏

【Golang】1.18泛型初步理解

https://rehtt.com/posts/253/

作者

Rehtt

发布于

2022-04-18

许可协议

CC BY-NC-SA 4.0

【Golang】Go的构建模式

【树莓派】板载LED控制

评论区

分享你的想法，与大家交流讨论

加载更多…

音乐

音乐