Que sont les génériques en langage Go

Dans le langage Go, les génériques signifient é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. En introduisant les concepts de paramètres formels de type et de paramètres réels de type, une fonction peut gérer plusieurs types de données différents. , cette façon de programmer est appelée programmation générique.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Go version 1.18 ajoute une nouvelle fonctionnalité : le support de la programmation générique.

Si vous êtes un développeur d'autres langages vers le langage Go, pouvez-vous comprendre ce que sont les génériques et comment les utiliser ?

Mais pour ceux qui débutent en langage Go et qui n'ont pas été exposés à la programmation générique, cette fonction peut prêter à confusion.

Cet article espère que les personnes exposées à la programmation générique pourront également bien comprendre et utiliser les génériques de Go

Une ligne directrice générale pour la programmation Go : écrire des programmes Go en écrivant du code, et non en définissant des types
Programmation Go Ligne directrice générale : écrire Go programmes en écrivant du code, pas en définissant des types

Que sont les génériques ?

---

Les génériques signifient é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 paramètres formels et les paramètres réels de la fonction

Les paramètres lorsque la fonction est définie sont formels paramètres (paramètre) , dans l'utilisation réelle de la fonction, les paramètres transmis sont des paramètres réels (argument)

Supposons qu'il existe une fonction d'addition. Les deux paramètres de cette fonction sont tous deux de type int. , et la valeur de retour est également int code> ; est définie comme suit : <code>int 类型，返回值也是 int；定义如下：

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

如果传入的两个实参都是 int 类型，那么函数自然能够正常执行。但是这个函数只能用来做 int 类型的加法运算，假设还需要进行 float64

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

Si les deux paramètres réels transmis sont tous deux 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. En supposant que des opérations d'addition de type float64 soient également nécessaires, nous devons écrire une autre fonction. [Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation

]

Il 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 peu convivial à lire.

À ce stade, nous réfléchirons à la question de savoir si une fonction peut recevoir tous les types de calcul, alors nous pouvons écrire une fonction de calcul en deux ou trois lignes de code. Cette fonction peut être réalisée 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. Le paramètre de type est utilisé lors de la définition et l'argument de type est utilisé lors de l'appel réel.

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

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

En introduisant les concepts de paramètres de type et de paramètres réels de type, une fonction peut traiter plusieurs types de données différents. Ce type de programmation. La méthode s'appelle 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, le traitement dynamique des types de données peut également être réalisé via l'interface + réflexion de Go. Les fonctions que les génériques peuvent réaliser peuvent essentiellement être réalisées via interface + 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
Perte de lors de la compilation, la vérification de type est sujette à des bugs
mauvaises performances

Mais on ne peut pas dire que tous les scénarios utilisent des génériques ne sont pas une panacée. Les génériques ont des scénarios applicables correspondants. Vous pouvez lire sur le concepteur générique de Go, Ian Lance Taylor, a publié un. article sur le site du blog officielquand 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 l'utilisation de génériques est la plus appropriée Sélectionnez

Exemple de Go Generics

---

Fonctions génériques

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

Types génériques

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

Déclarer la contrainte de type

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

rrreeePour plus de connaissances sur la programmation, veuillez visiter : Vidéo de programmation

 ! ! 🎜

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!