Go1.18新特性之泛型使用三步曲(小结)

目录
  • 01 Go中的泛型是什么
    • 1.1 传统的函数编写方式
    • 1.2 泛型函数编写方式
  • 02 从泛型被加入之前说起
    • 2.1 针对每一种类型编写一套重复的代码
    • 2.2 使用空接口并通过类型断言来判定具体的类型
    • 2.3 传递空接口并使用反射解析具体类型
    • 2.4 通过自定义接口类型实现
  • 03 深入理解泛型--泛型使用“三步曲”
    • 3.1 第一步:类型参数化
    • 3.2 第二步:给类型添加约束
    • 3.3 第三步:类型参数实例化
  • 04 泛型类型约束和普通接口的区别
  • 总结

01 Go中的泛型是什么

众所周知,Go是一门静态类型的语言。静态类型也就意味着在使用Go语言编程时,所有的变量、函数参数都需要指定具体的类型,同时在编译阶段编译器也会对指定的数据类型进行校验。这也意味着一个函数的输入参数和返回参数都必须要和具体的类型强相关,不能被不同类型的数据结构所复用

泛型就是要解决代码复用和编译期间类型安全检查的问题而生的。这里给出我理解的泛型的定义:

泛型是静态语言中的一种编程方式。这种编程方式可以让算法不再依赖于某个具体的数据类型,而是通过将数据类型进行参数化,以达到算法可复用的目的。

下面,我们通过一个函数的传统编写方式和泛型编写方式先来体验一下。

1.1 传统的函数编写方式

例如,我们有一个函数Max,其功能是计算整型切片中的最大元素,则其传统的编写方式如下:

func Max(s []int) int {
	if len(s) == 0 {
		return 0
	}

	max := s[0]
	for _, v := range s[1:] {
		if v > max {
			max = v
		}
	}

	return max
}

m1 := Max([]int{4, -8, 15})

在该示例中,Max函数的输入参数和返回值类型已经被指定都是int类型,不能使用其他类型的切片(例如s []float)。如果想要获取float类型的切片中的最大元素,则需要再写一个函数:

func MaxFloat(s []float) float {
	//...
}

传统的编写方式的缺点就是需要针对每一种类型都要编写一个函数,除了函数的参数中的类型不一样,其他逻辑完全一样

接下来我们看看使用泛型的写法。

1.2 泛型函数编写方式

为了能够使编写的程序更具有可复用性,通用编程(Generic programming)也应运而生。使用泛型,函数或类型可以基于类型参数进行定义,并在调用该函数时动态指定具体的类型对其进行实例化,以达到函数或类型可以基于一组定义好的类型都能使用的目的。我们通过泛型将上述Max函数进行改写:

import (
	"fmt"
	"golang.org/x/exp/constraints"
)

func main() {
	m1 := Max[int]([]int{4, -8, 15})
	m2 := Max[float64]([]float64{4.1, -8.1, 15.1})

	fmt.Println(m1, m2)
}

// 定义泛型函数
func Max[T constraints.Ordered](s []T) T {
	var zero T
	if len(s) == 0 {
		return zero
	}
	var max T
	max = s[0]
	for _, v := range s[1:] {
		max = v
		if v > max {
			max = v
		}
	}

	return max
}

由以上示例可知,我们通过使用泛型改写了MaxNumber函数,在main函数中调用MaxNumber时,通过传入一个具体的类型就能复用MaxNumber的代码了。

好了,这里我们只是对泛型有了一个初探,至于泛型函数中的Tany等关键词暂时不用关系,在后面我们会详细讲解。

接下来我们从泛型被加入之前说起,从而更好的的理解泛型被加入的动机。

02 从泛型被加入之前说起

为了更好的理解为什么需要泛型,我们看看如果不使用泛型如何实现可复用的算法。还是以上面的返回切片中元素的最大值函数为例。

为了能够针对切片中不同的数据类型都可以复用,我们一般有以下几种方案:

  • 针对每一种类型编写一套重复的代码
  • 传递一个空接口interface{},使用类型断言来判断是哪种数据类型
  • 传递一个空接口interface{},使用反射机制来判断是哪种数据类型
  • 自定义接口类型,通过类型继承的方式实现具体逻辑

下面我们看上面每一种实现方法都有哪些缺点。

2.1 针对每一种类型编写一套重复的代码

这种方法我们在第一节中已经实现了。针对int切片和float切片各自实现一个函数,但在两个函数中只有切片的数据类型不同,其他逻辑都相同。

这种方法的主要缺点就是大量的重复代码。这两个函数中除了切片元素的数据类型不同之外,其他都一样。同时,大量重复的代码也降低了代码的可维护性

2.2 使用空接口并通过类型断言来判定具体的类型

另外一种方法是函数接收一个空接口的参数。在函数内部使用类型断言和switch语句来选择是哪种具体的类型。最后将结果再包装到一个空接口中返回。如下:

func Max(s []interface{}) (interface{}, error) {
    if len(s) == 0 {
        return nil, errors.New("no values given")
    }

    switch first := s[0].(type) {
        case int:
            max := first
            for _, rawV := range s[1:] {
                v := rawV.(int)
                if v > max {
                    max = v
                }
            }
            return max, nil

        case float64:
            max := first
            for _, rawV := range s[1:] {
                v := rawV.(float64)
                if v > max {
                    max = v
                }
            }
            return max, nil

         default:
             return nil, fmt.Errorf("unsupported element type of given slice: %T", first)
    }
}

// Usage
m1, err1 := Max([]interface{}{4, -8, 15})
m2, err2 := Max([]interface{}{4.1, -8.1, 15.1})

这种写法的主要有两个缺点。第一个缺点是在编译期间缺少类型安全检查。如果调用者传递了一个不支持的数据类型,该函数的实现应该是返回一个错误。第二个缺点是这种实现的可用性也不是很好。因为无论是调用者处理返回值还是在函数内部的实现代码都需要将具体的类型包装在一个空接口中,并使用类型断言来判断接口里的具体的类型。

2.3 传递空接口并使用反射解析具体类型

在从空接口中解析具体的类型时,我们还可以通过反射替代类型断言。如下实现:

func Max(s []interface{}) (interface{}, error) {
    if len(s) == 0 {
	return nil, errors.New("no values given")
    }

    first := reflect.ValueOf(s[0])

    if first.Type().Name() == "int"  {
        max := first.Int()
        for _, ifV := range s[1:] {
            v := reflect.ValueOf(ifV)
            if v.Type().Name() == "int" {
                intV := v.Int()
		if intV > max {
                    max = intV
		}
            }
	}
	return max, nil
    }

    if first.Type().Name() == "float64" {
        max := first.Float()
	for _, ifV := range s[1:] {
            v := reflect.ValueOf(ifV)
            if v.Type().Name() == "float64" {
                intV := v.Float()
		if intV > max {
                    max = intV
		}
            }
	}
	return max, nil
    }

    return nil, fmt.Errorf("unsupported element type of given slice: %T", s[0])
}

// Usage
m1, err1 := Max([]interface{}{4, -8, 15})
m2, err2 := Max([]interface{}{4.1, -8.1, 15.1})

在这种方法中,在编译期间不仅没有类型的安全检查,同时可读性也差。而且在使用反射时,性能通常也会比较差。

2.4 通过自定义接口类型实现

另外一种方法,我们可以通过给函数传递一个具体的,预定义好的接口来实现。该接口应该包含该函数要实现的功能的必备方法。只要实现了该接口的类型,该方法就都可以支持。我们还是以上面的MaxNumber函数为例,应该有获取元素个数的方法Len,比较大小的方法Less以及获取元素的方法Elem。我们来看看具体的实现:

type ComparableSlice interface {
    // 返回切片的元素个数.
    Len() int
    // 比较索引i的元素值是否比索引j的元素值要小
    Less(i, j int) bool
    // 返回索引i位置的元素
    Elem(i int) interface{}
}

func Max(s ComparableSlice) (interface{}, error) {
    if s.Len() == 0 {
        return nil, errors.New("no values given")
    }

    max := s.Elem(0)
    for i := 1; i < s.Len(); i++ {
        if s.Less(i-1, i) {
            max = s.Elem(i)
        }
    }

    return max, nil
}

type ComparableIntSlice []int

func (s ComparableIntSlice) Len() int { return len(s) }
func (s ComparableIntSlice) Less(i, j int) bool { return s[i] < s[j] }
func (s ComparableIntSlice) Elem(i int) interface{} { return s[i] }

type ComparableFloat64Slice []float64

func (s ComparableFloat64Slice) Len() int { return len(s) }
func (s ComparableFloat64Slice) Less(i, j int) bool { return s[i] < s[j] }
func (s ComparableFloat64Slice) Elem(i int) interface{} {return s[i]}

// Usage
m1, err1 := Max(ComparableIntSlice([]int{4, -8, 15}))
m2, err2 := Max(ComparableFloat64Slice([]float64{4.1, -8.1, 15.1}))

在该实现中,我们定义了一个ComparableSlice接口,其中ComparableIntSliceComparableFloat64Slice两个具体的类型都实现了该接口,分别对应int类型切片和float64类型切片。

该实现的一个明显的缺点是难以使用。因为调用者必须将数据封装到一个自定义的类型中(在该示例中是ComparableIntSlice和ComparableFloat64Slice),并且该自定义类型要实现已定义的接口ComparableSlice。

由以上示例可知,在有泛型功能之前,要想在Go中实现处理多种类型的可复用的函数,都会带来一些问题。而泛型机制正是避免上述各种问题的解决方法。

03 深入理解泛型--泛型使用“三步曲”

在文章第一节处我们已经提到过泛型要解决的问题--程序针对一组类型可进行复用。下面我们给出泛型函数的一般形式,如下图:

由上图的泛型函数的一般定义形式可知,使用泛型可以分三步,我将其称之为“泛型使用三步曲”。

3.1 第一步:类型参数化

在定义泛型函数时,使用中括号给出类型参数类型,并在函数所接收的参数中使用该类型参数,而非具体类型,就是所谓的类型参数化。还是以上面的泛型函数为例:

func Max[T constraints.Ordered](s []T) T {
    var zero T
    if len(s) == 0 {
	return zero
    }

    var max T
    max = s[0]
    for _, v := range s[1:] {
	max = v
	if v > max {
            max = v
	}
    }

    return max
}

其中T被称为类型参数,即不再是一个具体的类型值,而是需要在调用该函数时再动态的传入一个类型值(例如int,float64),以实例化化T。例如:Max[int](s[]int{4,-8,15}),那么T就代表的是int。

当然,类型参数列表中可以有多个类型参数,多个类型参数之间用逗号隔开即可。类型参数名也不一定非要用T,任何符合变量规则的名称都可以。

3.2 第二步:给类型添加约束

在上图中,any被称为是类型约束,用来描述传给T的类型值应该满足什么样的条件,不满足约束的类型传给T时会被报编译错误,这样就实现了类型的安全机制。当然类型约束不仅仅像any这么简单。

在Go中类型约束分两类,分别是Go官方支持的内建类型约束(包括内建的类型约束any、comparable和在golang.org/x/exp/constraints 包中定义的类型约束)和自定义类型约束。因为在Go中泛型的约束是通过接口来实现的,所以我们可以通过定义接口来自定义类型约束

3.2.1 Go官方支持的内建类型约束

其中Go内建的类型约束和constraints包定义的类型约束我们统一成为Go官方定义的类型约束。之所以是在golang.org/x/exp/constraints包中,是因为该约束带有实验性质。

下面我们列出了Go官方支持的预定义的类型约束:

约束 描述 位置
any 任意类型;可以看做是空接口interface{}的别名 go内建
comparable 可比较的值类型,即该类型的值可以使用==!=操作符进行比较(例如bool、数字类型、字符串、指针、通道、接口、值是可比较类型的数组、字段都是可比较类型的结构体等) go内建
Signed - 有符号整型 ~int | ~int8 | ~int16 | ~int32 | ~int64 golang.org/x/exp/constraints
Unsigned - 有符号整型 ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr golang.org/x/exp/constraints
Integer - 整型 Signed | Unsigned golang.org/x/exp/constraints
Float - 浮点型 ~float32 | ~float64 golang.org/x/exp/constraints
Complex - 复数型 ~complex64 | ~complex128 golang.org/x/exp/constraints
Ordered Integer | Float | ~string(支持<、<=、>=、>操作符的任意类型) golang.org/x/exp/constraints

在上表中,我们看到的符号~~T意思是说底层类型是T的类型。例如~int代表的是底层类型是int的类型。这个我们在下一节自定义类型约束一节有详细介绍和示例。

3.2.2 自定义类型约束

由上面可知,类型的约束本质上是一个接口。所以,如果官方提供的类型约束不满足自己的业务场景下,可以按照Go中泛型的语法规则自定义类型约束即可。类型约束的定义一般有两种形式:

  • 定义成接口形式
  • 直接定义在类型参数列表中

下面我们分别来看下各自的使用方法。

  • 定义成接口形式

下面是定义成接口形式的类型约束示例:

// 自定义类型约束接口StringableFloat
type StringableFloat interface {
    ~float32 | ~float64 // 底层是float32或float64的类型就能满足该约束
    String() string
}

// MyFloat 是满足StringableFloat类型约束的float类型。
type MyFloat float64 

// 实现类型约束中的String方法
func (m MyFloat) String() string {
    return fmt.Sprintf("%e", m)
}

//泛型函数,对类型参数T使用了StringableFloat约束
func StringifyFloat[T StringableFloat](f T) string {
    return f.String()
}
// Usage
var f MyFloat = 48151623.42

//使用MyFloat类型对T进行实例化
s := StringifyFloat[MyFloat](f)

在该示例中,函数StringifyFloat是一个泛型函数,并使用StringableFloat接口来对T进行约束。MyFloat类型是一个满足StringableFloat约束的具体类型。

在泛型中,类型约束被定义成了接口,该接口中可以包含具体类型的集合和方法。在该示例中,StringfyFloat类型约束包含float32和float64两个类型以及一个String()方法。该约束允许任何满足该接口的具体类型都可以实例化参数T。

在上述示例中,我们还看到一个新的关键符号:~~T代表所有的类型的底层类型必须是类型T。在这里类型MyFloat是一个自定义的类型,但其底层类型或叫做基础类型是float64。因此,MyFloat是满足StringifyFloat约束的。

另外,在定义类型约束接口中,也可以引入类型参数。如下示例中,在类型约束SliceConstraints中的切片类型引入了类型参数E,这样该约束就可以对任意类型的切片进行约束了。

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

func main() {
    r1 := FirstElem1[[]string, string]([]string{"Go", "rocks"})
    r2 := FirstElem1[[]int, int]([]int{1, 2})

    fmt.Println(r1, r2)
}

// 定义类型约束,并引入类型参数E
type SliceConstraint[E any] interface {
    ~[]E
}

// 泛型函数
func FirstElem1[S SliceConstraint[E], E any](s S) E {
	return s[0]
}
  • 在类型参数列表中直接定义约束

下面的示例中,FirstElem2、FirstElem3泛型函数将类型约束直接定义在了类型参数列表中,我把它称之为匿名类型约束接口,类似于匿名函数。如下示例代码,三个泛型函数是等价的:

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

func main() {
    s := []string{"Go", "rocks"}
    r1 := FirstElem1[[]string, string](s)
    r2 := FirstElem2[[]string, string](s)
    r3 := FirstElem3[[]string, string](s)

    fmt.Println(r1, r2, r3)
}

type SliceConstraint[E any] interface {
    ~[]E
}

func FirstElem1[S SliceConstraint[E], E any](s S) E {
    return s[0]
}

func FirstElem2[S interface{ ~[]E }, E any](s S) E {
    return s[0]
}

func FirstElem3[S ~[]E, E any](s S) E {
    return s[0]
}

3.3 第三步:类型参数实例化

在调用泛型函数时,需要给函数的类型参数指定具体的类型,叫做类型实例化。在类型实例化过程中有时候是不需要指定的具体的类型,这时在编译阶段,编译器会根据函数的参数自动推导出来T的实际参数值。如下:

类型参数实例化就比较简单了,就是在调用泛型函数时要给泛型函数的类型参数传递一个具体的类型。就像第一步中调用Max函数时指定的一样:r2 := Max[int]([]int{4, 8, 15}),这里Max后面中括号中的int就是类型实参,这样Max函数就能知道处理的切片元素的具体类型了。

这里还有一点需要注意,在类型参数实例化时,还有方式是不需要指定具体的类型,这时在编译阶段,编译器会根据函数的参数自动推导出来T的实际参数值: r3 := Max([]float64{4.1, -8.1, 15.1})。这里Max后面并没有给出中括号以及对应的具体类型,但Go编译器能根据切片元素类型自动推断出是float64类型。

04 泛型类型约束和普通接口的区别

首先二者都是接口,都可以定义方法。但类型约束接口中可以定义具体类型,例如上文中自定义的StringableFloat类型约束接口中的类型约束:~float32 | ~float64

type StringableFloat interface {
    ~float32 | ~float64 // 底层是float32或float64的类型就能满足该约束
    String() string
}

当接口中存在类型约束时,这时该接口就只能被用于泛型类型参数的约束。

总结

泛型在Go1.18中才被加入实际上是有其原因的。之前一直都有泛型的提案,但一直没被加入到该语言中,其中一个很重要的原因就是因为之前的泛型提案不够简单。而Go又是以简单著称的语言,所以只有泛型的实现方案足够简单,同时对Go之前的版本又兼容时才被加入进来。

到此这篇关于Go1.18新特性之泛型使用三步曲(小结)的文章就介绍到这了,更多相关Go1.18 泛型内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Go1.18都出泛型了速来围观

    go泛型使用的官方说明:https://go.dev/doc/tutorial/generics 在使用之前先把go更新到1.18或者以上的版本:https://go.dev/doc/install 如果用过c++或者Java的话,那么对泛型这个概念应该是不陌生的.(下面这段定义摘抄自百度百科)泛型程序设计(generic programming)是程序设计语言的一种风格或范式.泛型允许程序员在强类型程序设计语言中编写代码时使用一些以后才指定的类型,在实例化时作为参数指明这些类型. 我们可以用个

  • 浅谈Go1.18中的泛型编程

    目录 前言 以前的Go泛型 泛型是什么 Go的泛型 泛型函数 泛型类型 类型集合 和接口的差异 总结 前言 经过这几年的千呼万唤,简洁的Go语言终于在1.18版本迎来泛型编程.作为一门已经有了14年历史的强类型语言,很难相信它到现在才开始有一个正式的泛型. 以前的Go泛型 虽然直到1.18版本才加入泛型,但是在2014年便有相关的讨论要在Go中加入泛型设计.但是由于各种原因没有实现.而之后的接口(interface)的提出,让泛型进一步搁置.但是由于接口的缺陷,最终Go团队还是在1.18的版本中

  • Go1.18新特性之泛型使用三步曲(小结)

    目录 01 Go中的泛型是什么 1.1 传统的函数编写方式 1.2 泛型函数编写方式 02 从泛型被加入之前说起 2.1 针对每一种类型编写一套重复的代码 2.2 使用空接口并通过类型断言来判定具体的类型 2.3 传递空接口并使用反射解析具体类型 2.4 通过自定义接口类型实现 03 深入理解泛型--泛型使用“三步曲” 3.1 第一步:类型参数化 3.2 第二步:给类型添加约束 3.3 第三步:类型参数实例化 04 泛型类型约束和普通接口的区别 总结 01 Go中的泛型是什么 众所周知,Go是一

  • Go1.18新特性对泛型支持详解

    目录 1.泛型是什么 2.泛型类型的定义 2.1.声明一个自定义类型 2.2.内置的泛型类型any和comparable 2.3.泛型中的~符号是什么 1.泛型是什么 Go1.18增加了对泛型的支持,泛型是一种独立于使用的特定类型编写代码的方式.现在可以编写函数和类型适用于一组类型集合的任何一种.泛型生命周期只在编译期,旨在开发中减少重复代码的编写. 由于go属于静态强类型语言,例如在比较两个数的大小时,没有泛型的时候,仅仅只是传入类型不一样,我们就要再复制一份一样的函数,如果有了泛型就可以减少

  • Go1.18新特性使用Generics泛型进行流式处理

    前言 Stream 是一个基于 Go 1.18+ 泛型的流式处理库, 它支持并行处理流中的数据. 并行流会将元素平均划分多个的分区, 并创建相同数量的 goroutine 执行, 并且会保证处理完成后流中元素保持原始顺序. GitHub - xyctruth/stream: A Stream library based on Go 1.18+ Generics (Support Parallel Stream) 安装 需要安装 Go 1.18+ 版本 $ go get github.com/xy

  • Go1.18 新特性之多模块Multi-Module工作区模式

    目录 背景 举例:未发布的 module Go1.18 新特性:多模块(Multi-Module)工作区模式 Go1.18 工作区模式 初始化一个新的工作区 go.work 文件结构 go.work 文件优先级高于 go.mod 中定义在 如何禁用工作区 背景 在 go 中使用多个模块可能真的是一件苦差事.特别是当您的一个模块依赖于另一个模块时,您需要同时编辑这两个模块! 您编辑父模块,但是然后您需要将其推送到repo.然后在依赖模块中运行 update 以下载新版本.最终使用2行修复您需要的.

  • Go1.18新特性工作区模糊测试及泛型的使用详解

    目录 前言 Go工作区模式(Go Workspace Mode) 现实的情况 多仓库同时开发 多个新仓库开始开发 工作区模式是什么 推荐的使用方法 使用时的注意点 Go模糊测试(Go Fuzzing Test) 为什么Golang要支持模糊测试 模糊测试是什么 Golang的模糊测试如何使用 最简单的实践例子 提供自定义语料 使用时的注意点 Go的泛型 类型参数(Type Parameters) 类型集合(Type Sets) 类型推导(Type Inference) 类型统一化(Type Un

  • Java8新特性之泛型的目标类型推断_动力节点Java学院整理

    简单理解泛型 泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数.通俗点将就是"类型的变量".这种类型变量可以用在类.接口和方法的创建中. 理解Java泛型最简单的方法是把它看成一种便捷语法,能节省你某些Java类型转换(casting)上的操作: List<Apple> box = new ArrayList<Apple>(); box.add(new Apple());Apple apple =box.ge

  • go开源Hugo站点构建三步曲之集结渲染

    目录 Assemble PageState 动手实践 - Show Me the Code of Create a PageState Render 动手实践 - Show Me the Code of Publish Assemble Assemble所做的事情很纯粹,那就是创建站点页面实例 - pageState. 因为支持多站点,contentMaps有多个. 所以Assemble不仅要创建pageState,还需要管理好所有的pages,这就用到了PageMaps. type pageM

  • Mybatis实现自定义的typehandler三步曲

    第一步实现接口TypeHandler<T> @MappedJdbcTypes(JdbcType.TIMESTAMP)//此处如果不使用该注解,在myabtis-config.xml中注册该typehandler的时候需要写明jdbctype="TIMESTAMP" @MappedTypes(DateTime.class)//此处如果不使用该注解,在myabtis-config.xml中注册该typehandler的时候需要写明javatype="com.sinos

  • ubuntu 16.04 64位兼容32位程序三步曲

    第一步:确认自己系统的架构 dpkg --print-architecture 输出: amd64 结果为 amd64 表示系统是64位的 第二步:确认打开了多架构支持功能 dpkg --print-foreign-architectures 输出: i386 如果这里没有输出i386,则需要打开多架构支持 sudo dpkg --add-architecture i386 sudo apt-get update 第三步:安装对应的32位的库 sudo apt-get dist-upgrade

  • Go1.16新特性embed打包静态资源文件实现

    目录 背景 embed 嵌入 字符串.字节切片.文件嵌入 嵌入文件 嵌入文件夹 嵌入匹配 FS 文件系统 总结: 背景 相信有一部分人喜爱 GO 的初衷大概是:跨平台静态编译,如果在没用通过 CGO 引用其他库的话,一般编译出来的可执行二进制文件部署起来非常方便,但人们在实际中发现,使用 Go 语言开发的后端 WEB 程序存在 HTML 模版.图片.JS.CSS.JSON 等静态资源,部署时需要把这些静态资源与二进制程序一起上传到服务器部署,在现今遍地花容器的今天,为了简化部署流程,能不能更进一

随机推荐