Que signifient les génériques en golang ?

Les génériques en Golang signifient écrire des modèles pour s'adapter à tous les types. Les types de variables spécifiques ne sont définis que lorsqu'ils sont utilisés spécifiquement. Les génériques sont un style ou un paradigme de langages de programmation. Les génériques permettent aux programmeurs d'écrire dans des langages de programmation fortement typés. qui sont spécifiés ultérieurement et sont spécifiés en tant que paramètres lors de l'instanciation. Lorsque vous écrivez du code avec exactement la même logique pour différents types, l'utilisation de génériques est le choix le plus approprié.

L'environnement d'exploitation de ce tutoriel : système Windows 10, version go1.20.1, ordinateur Dell G3.

Que sont les génériques ?

Les génériques consistent à écrire des modèles pour s'adapter à tous les types et à définir des types de variables spécifiques uniquement lorsqu'ils sont utilisés spécifiquement.

Les génériques sont un style ou un paradigme de langages de programmation. Les génériques permettent aux programmeurs d'écrire du code dans un langage de programmation fortement typé en utilisant des types spécifiés ultérieurement et spécifiés en tant que paramètres au moment de l'instanciation.

Les paramètres formels et les paramètres réels de la fonction

Les paramètres lorsque la fonction est définie sont des paramètres formels (paramètre), et les paramètres transmis lorsque la fonction est réellement utilisée sont des paramètres réels (argument)

Supposons qu'il y ait est une fonction d'addition.Cette fonction a Les deux paramètres sont de type int, et la valeur de retour est également int ;la définition est la suivante :

func Test(a,b int) int {
    return a + b
}

Si les deux paramètres réels transmis sont de type int, alors la fonction s'exécutera naturellement. normalement. Cependant, cette fonction ne peut être utilisée que pour effectuer des opérations d'addition de type int. Si nous devons également effectuer des opérations d'addition de type float64, nous devons écrire une autre fonction.

Ce n'est pas gênant d'écrire deux ou trois types de calculs d'addition, il suffit de copier et coller. Mais si tous les types calculables doivent être ajoutés, le code ne sera pas suffisamment rationalisé et sera très peu convivial à lire. À ce stade, nous réfléchirons à la question de savoir si une fonction peut recevoir tous les types de calcul, donc seulement deux ou trois lignes de code. J'ai fini d'écrire une fonction de calcul. Cette fonction peut être obtenue en définissant simplement une combinaison de types ou un espace réservé sans spécifier de type spécifique lors de la définition des paramètres de fonction

Cette combinaison de types ou espace réservé est le paramètre de type, et le paramètre de type est utilisé lors de la définition (paramètre de type), utilisez le type argument lors de l'appel réel

La fonction de calcul initiale est convertie en fonction de paramètre de type comme suit :

// T 是一个类型形参，在定义函数时类型是不确定的，这里的 any 是 go 泛型定义好的一组类型组合
func Test[T any](a,b T) T {
    return a + b
}
// 调用时传入类型实参，伪代码Test[int](1,2)
Test(1,2)

En introduisant les concepts de paramètres de type et d'arguments de type, une fonction peut La capacité de traiter plusieurs types de données différents, cette méthode de programmation s'appelle la programmation générique

Pourquoi les génériques ?

Dans l'exemple d'ajout précédent, en plus d'utiliser des génériques, vous pouvez également obtenir une dynamique via l'interface de Go + réflexion Gestion des types de données. Les fonctions que les génériques peuvent réaliser peuvent essentiellement être réalisées via des interfaces + réflexion, mais si vous avez utilisé la réflexion, vous comprendrez que le mécanisme de réflexion présente de nombreux problèmes :

Il est difficile à utiliser et nécessite une forte réflexion logique et une compilation. la vérification du type de temps est perdue. Sujet aux bugs et aux mauvaises performances

Mais on ne peut pas dire que les génériques doivent être utilisés dans tous les scénarios. Les génériques ont des scénarios applicables correspondants. sur le site du blog officiel Publication d'un article « quand utiliser les génériques

» pour résumer les scénarios d'utilisation des génériques en une phrase : Lorsque vous écrivez du code avec exactement la même logique pour différents types, alors utiliser des génériques est le choix le plus approprié.

Exemple de génériques Go

Fonctions génériques

// Add sums the values of T. It supports string, int, int64 and float64
//
// @Description A simple additive generic function
// @Description 一个简单的加法泛型函数
// @parameter   a, b    T string | int | int64 | float64    "generics parameter"
// @return      c       T string | int | int64 | float64    "generics return"
func Add[T string | int | int64 | float64](a, b T) T {
    return a + b
}
 
// 使用
Add(1, 2)
Add(1.0,2.0)

Types génériques

// MyChan Custom generics chan type
// 一个泛型通道，可用类型实参 int 或 string 实例化
type MyChan[T int | string] chan T

Déclarer les contraintes de type (contrainte de type)

Les contraintes de type dans Go sont implémentées via des interfaces

// CustomizationGenerics custom generics
//
// @Description custom generics, which are type restrictions
// @Description ~is a new symbol added to Go 1.18, and the ~ indicates that the underlying type is all types of T. ~ is pronounced astilde in English
// @Description 自定义泛型，即类型限制
// @Desciption ~ 是 Go 1.18 新增的符号，~ 表示底层类型是T的所有类型。~ 的英文读作 tilde
//
// @Example With the addition of ~, MyInt can be used, otherwise there will be type mismatch
// @Example 加上 ~，那么 MyInt 自定义的类型能够被使用，否则会类型不匹配
type CustomizationGenerics interface {
    ~int | ~int64
}

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!