Pemahaman mendalam tentang generik dalam golang (Generik)

Kandungan artikel ini adalah untuk memperkenalkan anda kepada pemahaman mendalam tentang generik dalam golang? Bagaimana untuk menggunakan generik? Ia mempunyai nilai rujukan tertentu Rakan-rakan yang memerlukan boleh merujuk kepadanya.

Apakah itu generik

Generik ialah teknologi pengaturcaraan. Dalam bahasa yang ditaip kuat, anda dibenarkan menulis kod menggunakan jenis yang ditentukan kemudian, dan menentukan jenis yang sepadan pada masa instantiasi.

Dalam generik, parameter jenis boleh digunakan dan bukannya jenis data tertentu. Parameter jenis ini boleh diisytiharkan dalam kelas, kaedah atau antara muka, dan boleh digunakan dalam pengisytiharan ini. Kod menggunakan generik boleh menentukan parameter jenis sebenar pada masa jalan, yang membolehkan kod digunakan pada pelbagai jenis data.

Generik boleh meningkatkan kebolehbacaan, kebolehselenggaraan dan kebolehgunaan semula kod. Ia mengurangkan lebihan kod anda dan menyediakan keselamatan jenis yang lebih baik dan pemeriksaan jenis masa kompilasi.

Kami menggunakan contoh khusus untuk menerangkan sebab generik boleh mengurangkan redundansi kod:

Sediakan fungsi yang mengembalikan nilai minimum a dan b Kami memerlukan setiap Tulis fungsi menggunakan a jenis data khusus "int, float..."; atau gunakan antara muka{} "Ia memerlukan penegasan jenis untuk parameter, yang mempengaruhi prestasi berjalan dan tidak boleh mengekang parameter yang dihantar"

func minInt(a, b int) int {
    if a > b {
        return b
    }
    return a
}

func minFloat(a, b float64) float64 {
    if a > b {
        return b
    }
    return a
}

func minItf(a, b interface{}) interface{} {
    switch a.(type) {
    case int:
        switch b.(type) {
        case int:
            if a.(int) > b.(int) {
                return b
            }
            return a
        }
    case float64:
        switch b.(type) {
        case float64:
            if a.(float64) > b.(float64) {
                return b
            }
            return a
        }
    }
    return nil
}

Daripada kaedah di atas kita dapat melihat bahawa kecuali untuk jenis parameter yang berbeza dan hasil pulangan, minInt dan minFloat mempunyai kod yang sama. Adakah terdapat cara untuk menentukan jenis yang diluluskan apabila fungsi dipanggil tanpa menyatakan jenis tertentu? Di sini, konsep yang dipanggil generik diperkenalkan, yang boleh difahami secara ringkas sebagai jenis luas atau jenis khusus yang tidak ditentukan. Dengan memperkenalkan generik, kami tidak perlu lagi menentukan jenis data tertentu Fungsi min boleh digunakan dengan cara berikut:

// T 为类型参数, 在调用时确定参数的具体值, 可以为 int, 也可以为 float64；它与 a, b 一样也是参数, 需要调用时传入具体的值；不同的是，T 为类型参数，值为具体的类型, a,b 为函数参数，值为具体类型对应的值
func minIntAndFloat64[T int | float64](a, b T) T { 
    if a < b {
        return a
    }
    return b
}

minIntAndFloat64[int](1, 2) // 实例化/调用时指定具体的类型

Generics in go

<.>Perkenalkan generik dalam versi 1.8. Jika versi go anda lebih rendah daripada 1.8, anda tidak boleh menggunakan generik. Kod dalam artikel ini menggunakan versi 1.9. Dalam versi 1.8, banyak perubahan telah dibuat untuk menyokong generik.

Parameter jenis yang diperkenalkan dalam pengisytiharan fungsi dan jenis
• Koleksi jenis boleh ditakrifkan melalui antara muka, termasuk jenis tanpa kaedah
• Terbitan jenis, dalam beberapa senario Jenis parameter akan disimpulkan, dan nilai parameter jenis tidak boleh ditentukan apabila memanggil fungsi

Parameter formal, parameter sebenar, parameter jenis, parameter sebenar jenis, instantiasi

Mari kita lihat fungsi

biasa dahulu. add ialah nama fungsi, add ialah parameter formal dan x, y ialah senarai parameter. Apabila panggilan fungsi berlaku, (x,y int) 2, 3 ialah parameter sebenar. add(2, 3)

Dengan analogi kepada generik, kita memerlukan parameter jenis Apabila panggilan fungsi berlaku, parameter jenis yang sepadan dihantar masuk. Fungsi dengan parameter jenis dipanggil fungsi generik. ialah senarai parameter jenis, [T int | int64] ialah parameter jenis dan T ialah kekangan koleksi/jenis jenis. Apabila panggilan fungsi berlaku int | int64, int ialah parameter sebenar jenis Panggilan ini juga dipanggil instantiasi, iaitu, parameter sebenar jenis ditentukan. add[int](2,3)

Parameter jenis juga boleh ditentukan semasa mengisytiharkan struktur.

ialah struktur generik dan boleh menentukan kaedah untuk struktur generik. MyStruct[T]

Taip koleksi, antara muka

Dalam jenis asas, uint8 mewakili set 0~255. Kemudian untuk parameter jenis, anda juga perlu menentukan koleksi jenis sama seperti jenis asas. Dalam contoh di atas

ialah koleksi jenis. Jadi bagaimana untuk menggunakan semula koleksi jenis? Antara muka digunakan di sini untuk definisi. Berikut ialah definisi koleksi jenis. Oleh itu, kita boleh mentakrifkan fungsi generik int | string add[T Signed](x, y T) T

Sebelum pergi 1.8, takrifan antara muka ialah koleksi kaedah, iaitu, jika anda melaksanakan kaedah yang sepadan kepada antara muka, anda boleh Tukar kepada antara muka yang sepadan. Dalam contoh di bawah, jenis

melaksanakan kaedah Tambah dan oleh itu boleh ditukar kepada MyInt. MyInterface

type MyInterface interface {
    Add(x, y int) int
}

type MyInt int

func (mi myInt) Add(x, y int) int {
    return x + y
}

func main() {
    var mi MyInterface = myInt(1)
    fmt.Println(mi.Add(1, 2))
}

Jika kita memikirkannya dari sudut lain,

boleh dilihat sebagai koleksi jenis, yang merangkumi semua jenis yang melaksanakan kaedah MyInterface. Kemudian, MyInterface boleh digunakan sebagai koleksi jenis. Sebagai contoh, kita boleh mentakrifkan fungsi generik seperti berikut. add

func I[T MyInterface](x, y int, i T) int {
    return i.Add(x, y)
}

在泛型中, 我们的类型集合不仅仅是实现接口中定义方法的类型, 还需要包含基础的类型。因此, 我们可以对接口的定义进行延伸, 使其支持基础类型。为了保证向前兼容, 我们需要对接口类型进行分类：

基础接口类型

只包含方法的集合, 既可以当作类型集合, 又可以作为数据类型进行声明。如下面的 MyInterface。还有一个特殊的接口类型 interface{}, 它可以用来表示任意类型, 即所有的类型都实现了它的空方法。在 1.8 之后可以使用 any 进行声明。

type any = interface{}

type MyInterface interface {
    Add(x, y int) int
    String() string
    String() string  // 非法: String 不能重复声明
    _(x int)         // 非法: 必须要有一个非空的名字
}

接口组合

可以通过接口组合的形式声明新的接口, 从而尽可能的复用接口。从下面的例子可以看出, ReadWriter是 Reader 和 Write 的类型集合的交集。

type Reader interface {
        Read(p []byte) (n int, err error)
        Close() error
}

type Writer interface {
        Write(p []byte) (n int, err error)
        Close() error
}

// ReadWriter's methods are Read, Write, and Close.
type ReadWriter interface {
        Reader  // includes methods of Reader in ReadWriter's method set
        Writer  // includes methods of Writer in ReadWriter's method set
}

通用接口

上面说的接口都必须要实现具体的方法, 但是类型集合中无法包含基础的数据类型。如: int, float, string...。通过下面的定义, 可以用来表示包含基础数据类型的类型集合。在 golang.org/x/exp/constraints 中定义了基础数据类型的集合。我们可以看到 ～ 符号, 它表示包含潜在类型为 int | int8 | int16 | int32 | int64 的类型, | 表示取并集。Singed 就表示所有类型为 int 的类型集合。

// 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
}

type myInt int // 潜在类型为 int

func add[T constraints.Integer](x, y T) T {
        return x + y
}

func main() {
        var x, y myInt = 1, 2
        fmt.Println(add[myInt](x, y))
}

下面来看一些特殊的定义

// 潜在类型为 int, 并且实现了 String 方法的类型
type E interface {
    ~int
    String() string
}

type mInt int // 属于 E 的类型集合
func (m mInt) String() string {
    return fmt.Sprintf("%v", m)
}

// 潜在类型必须是自己真实的类型
type F interface {
    ~int
    // ~mInt  invalid use of ~ (underlying type of mInt is int)
    // ~error illegal: error is an interface
}

// 基础接口可以作为形参和类型参数类型, 通用类型只能作为类型参数类型, E 只能出现在类型参数中 [T E]
var x E                    // illegal: cannot use type E outside a type constraint: interface contains type constraints
var x interface{} = E(nil) // illegal: cannot use interface E in conversion (contains specific type constraints or is comparable)

类型推导

由于泛型使用了类型参数, 因此在实例化泛型时我们需要指定类型实参。 看下面的 case, 我们在调用函数的时候并没有指定类型实参, 这里是编译器进行了类型推导, 推导出类型实参, 不需要显性的传入。

func add[T constraints.Integer](x, y T) T {
    return x + y
}

func main() {
    fmt.Println(add(1, 1)) // add[int](1,1)
}

有时候, 编译器无法推导出具体类型。则需要指定类型, 或者更换写法, 也许可以推断出具体类型。

// 将切片中的值扩大
func Scale[E constraints.Integer](s []E, c E) []E {
    r := make([]E, len(s))
    for i, v := range s {
        r[i] = v * c
    }
    return r
}

func ScaleAndPrint(p Point) {
    r := Scale(p, 2)
    r.string() // 非法, Scale 返回的是 []int32
}

type Point []int32

func (p Point) string() {
    fmt.Println(p)
}

// 方法更新，这样传入的是 Point 返回的也是 Point
func Scale[T ~[]E, E constraints.Integer](s T, c E) T {
    r := make([]E, len(s))
    for i, v := range s {
        r[i] = v * c
    }
    return r
}

泛型的使用

go 是在 1.8 版本中开始引入泛型的。下面主要介绍一下什么时候使用泛型：

内置容器类型

在 go 中, 提供以下容器类型：map, slice, channel。当我们用到容器类型时, 且逻辑与容器具体的类型无关, 这个时候可以考虑泛型。这样我们可以在调用时指定具体的类型实参, 从而避免了类型断言。例如,下面的例子, 返回 map 中的 key。

// comparable 是一个内置类型, 只能用于对类型参数的约束。在 map 中, key 必须是可比较类型。
func GetKeys[K comparable, V any](m map[K]V) []K {
    res := make([]K, 0, len(m))
    for k := range m {
        res = append(res, k)
    }
    return res
}

通用的结构体

对于一些通用的结构体, 我们应该使用泛型。例如, 栈、队列、树结构。这些都是比较通用的结构体, 且逻辑都与具体的类型无关, 因此需要使用泛型。下面是一个栈的例子：

type Stack[T any] []T

func (s *Stack[T]) Push(item T) {
    *s = append(*s, item)
}

func (s *Stack[T]) Pop() T {
    if len(*s) == 0 {
        panic("can not pop item in emply stack")
    }
    lastIndex := len(*s) - 1
    item := (*s)[lastIndex]
    *s = (*s)[:lastIndex]
    return item
}

func main() {
    var s Stack[int]
    s.Push(9)
    fmt.Println(s.Pop())
    s.Push(9)
    s.Push(8)
    fmt.Println(s.Pop(), s.Pop())
}

通用的函数

有些类型会实现相同的方法, 但是对于这些类型的处理逻辑又与具体类型的实现无关。例如: 两个数比大小, 只要实现 Ordered 接口即可进行大小比较:

func Min[T constraints.Ordered](x, y T) T {
    if x < y {
        return x
    }

    return y
}

func main() {
    fmt.Println(Min(5, 6))
    fmt.Println(Min(6.6, 9.9))
}

总结

go 在引入泛型算是一次较大的改动。我们只有弄清楚类型参数、类型约束、类型集合、基础接口、通用接口、泛型函数、泛型类型、泛型接口等概念, 才能不会困惑。核心改动点还是引入了类型参数, 使用接口来定义类型集合。

当然，也不能为了使用泛型而使用泛型。还是要具体的 case 具体来分析。 简单的指导原则就是, 当你发现你的代码除了类型不同外, 其余代码逻辑都相同; 或者你写了许多重复代码, 仅仅是为了支持不同类型; 那么你可以考虑使用泛型。

推荐学习：Golang教程

Atas ialah kandungan terperinci Pemahaman mendalam tentang generik dalam golang (Generik). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!