Compréhension approfondie des génériques en golang (Générique)

Cet article vous apporte une compréhension approfondie des génériques en golang ? Comment utiliser les génériques ? Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Que sont les génériques

Le générique est une technologie de programmation. Dans un langage fortement typé, vous êtes autorisé à écrire du code en utilisant des types spécifiés ultérieurement et à spécifier le type correspondant au moment de l'instanciation.

Dans les génériques, les paramètres de type peuvent être utilisés à la place de types de données spécifiques. Ces paramètres de type peuvent être déclarés dans une classe, une méthode ou une interface et peuvent être utilisés dans ces déclarations. Le code utilisant des génériques peut spécifier les paramètres de type réels au moment de l'exécution, ce qui permet au code d'être appliqué à de nombreux types de données différents.

Les génériques peuvent améliorer la lisibilité, la maintenabilité et la réutilisabilité du code. Il réduit la redondance de votre code et offre une meilleure sécurité des types et une meilleure vérification des types au moment de la compilation.

Nous utilisons un exemple spécifique pour expliquer pourquoi les génériques peuvent réduire la redondance du code :

Fournir une fonction qui renvoie la valeur minimale de a, b. Nous avons besoin de chaque type de données spécifique "int, float. .."Écrire une fonction ; ou utilisez l'interface{}"Vous devez effectuer des assertions de type sur les paramètres, ce qui a un impact sur les performances d'exécution et ne peut pas contraindre les paramètres transmis"

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
}

De la méthode ci-dessus, nous pouvons voir que minInt et minFloat Sauf pour le différents types de paramètres et résultats renvoyés, le reste du code est le même. Existe-t-il un moyen de déterminer le type transmis lorsque la fonction est appelée sans spécifier de type spécifique ? Ici, un concept appelé génériques est introduit, qui peut être simplement compris comme un type large ou un type spécifique non spécifié. En introduisant des génériques, nous n'avons plus besoin de spécifier des types de données spécifiques. La fonction min peut être utilisée de la manière suivante :

// 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) // 实例化/调用时指定具体的类型

Génériques en go

go n'a introduit les génériques que dans la version 1.8. Si votre version Go est inférieure à 1.8, vous ne pouvez pas utiliser de génériques. Le code de cet article utilise la version 1.9. Dans la version 1.8, de nombreuses modifications ont été apportées pour prendre en charge les génériques.

• Paramètres de type introduits dans les déclarations de fonctions et de types
• Les collections de types peuvent être définies via des interfaces, y compris les types sans méthodes
• Dérivation de type Dans certains scénarios, les paramètres de type seront déduits et ne pourront pas être spécifiés lors de l'appel de fonctions. ​​de paramètres de type

Paramètres formels, paramètres réels, paramètres de type, paramètres réels de type, instanciation

Regardons d'abord une fonction add ordinaire. add est le nom de la fonction, x, y est le paramètre formel et (x, y int) est la liste des paramètres. Lorsqu'un appel de fonction se produit, add(2, 3) 2, 3 sont des paramètres réels. add 函数。add 为函数名, x, y 为形参, (x,y int)为参数列表。发生函数调用时, add(2, 3) 2, 3 为实参。

类比到泛型中, 我们需要一个类型参数, 当发生函数调用时传入对应的类型实参, 带有类型参数的函数叫做泛型函数。[T int | int64] 为类型参数列表, T 为类型参数, int | int64 为类型集合/类型约束。当发生函数调用时 add[int](2,3),int 即为类型实参, 这一调用我们也叫做实例化, 即确定类型实参。

在结构体声明时, 也可以指定类型参数。MyStruct[T] 是一个泛型结构体, 可以为泛型结构体定义方法。

类型集合、接口

在基础类型中, uint8 表示 0~255 的集合。那么对于类型参数, 也需要像基础类型一样, 定义类型的集合。在上面的例子中 int | string就是类型的集合。那么如何对类型的集合进行复用呢？这里就使用了接口来进行定义。下面就是一个类型集合的定义。因此, 我们可以定义一个泛型函数 add[T Signed](x, y T) T

在 go 1.8 之前, 接口的定义是方法的集合, 即实现了接口对应的方法, 就可以转换为对应的接口。在下面的例子中, MyInt 类型实现了 Add 方法, 因此可以转换为 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))
}

如果我们换个角度来思考一下, MyInterface 可以看作一个类型集合, 即包含了所有实现 add

Analogie avec Pan Dans le type, nous avons besoin d'un paramètre de type Lorsqu'un appel de fonction se produit, le paramètre réel de type correspondant est transmis. La fonction avec des paramètres de type est appelée fonction générique. [T int | int64] est une liste de paramètres de type, T est un paramètre de type et int | int64 est une collection de types/contrainte de type. . Lorsqu'un appel de fonction se produit add[int](2,3), int est le paramètre de type réel. Cet appel est également appelé instanciation, c'est-à-dire que le paramètre de type réel est déterminé. 🎜🎜🎜🎜à Lors de la déclaration d'une structure, vous pouvez également spécifier des paramètres de type. MyStruct[T] est une structure générique qui peut définir des méthodes pour les structures génériques. 🎜🎜🎜

🎜Collection de types, interface🎜🎜🎜Dans le type de base, uint8 représente un ensemble de 0~255. Ensuite, pour les paramètres de type, vous devez également définir une collection de types, tout comme le type de base. Dans l'exemple ci-dessus, int string est une collection de types. Alors comment réutiliser une collection de types ? Les interfaces sont utilisées ici pour la définition. Ce qui suit est la définition d’une collection de types. On peut donc définir une fonction générique add[T Signed](x, y T) T🎜🎜🎜🎜Avant la version 1.8, la définition d'une interface était un ensemble de méthodes, c'est-à-dire la méthode correspondant à l'interface a été implémenté. Convertir vers l’interface correspondante. Dans l'exemple suivant, le type MyInt implémente la méthode Add et peut donc être converti en MyInterface. 🎜

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

🎜Si nous y réfléchissons sous un autre angle, MyInterface peut être considéré comme une collection de types, qui inclut tous les types qui implémentent la méthode add. Ensuite, MyInterface peut être utilisée comme une collection de types. Par exemple, nous pouvons définir une fonction générique comme suit. 🎜

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教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!