Que sont les génériques en golang

Dans Golang, les génériques sont un style ou un paradigme de langage de programmation, ce qui signifie é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 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.

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 convertissant d'autres langages vers 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 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 existe une fonction d'addition, ceci Les deux paramètres de la fonction sont tous deux de type int, et la valeur de retour est également int la définition est la suivante : 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 peut naturellement s'exécuter normalement. Mais cette fonction ne peut être utilisée que pour effectuer des opérations d'addition de type <code>int. En supposant que des opérations d'addition de type float64 soient également nécessaires, nous devons écrire une autre fonction

two ou. 3. Il n'est pas difficile d'écrire des calculs d'addition de types, il suffit de copier et coller. Mais si tous les types calculables doivent être ajoutés, le code ne sera pas assez concis et sera très peu convivial à lire. A ce stade, nous réfléchirons 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 un type spécifique lors de la définition des paramètres de fonction. Cette combinaison de types ou cet espace réservé est un paramètre de type lors de la définition (paramètre de type), 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ètre de type

et

argument de type, la possibilité de permettre à une fonction de gérer plusieurs types de données différents s'appelle programmation générique

Pourquoi les génériques ?L'exemple d'ajout précédent, en plus d'utiliser des génériques, peut également Le traitement dynamique des types de données est implémenté 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 officiel
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 l'utilisation de génériques est la plus appropriée Sélectionnez

Exemple de génériques Go

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 les contraintes de type (contrainte de type)

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

【Rel recommandations recommandées :

Allez tutoriel vidéo

,

Enseignement de la 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!