Une exploration préliminaire des génériques dans Go1.18

La fonction que nous souhaitons implémenter aujourd'hui est : additionner toutes les valeurs de la carte.

Fonction non générique

Comment l'implémenter sans génériques ? Parce que la valeur peut avoir différents types, tels que : int64, float64, etc., sans génériques, différents types doivent être implémentés via différentes fonctions, nous l'implémentons donc généralement comme suit :

func SumInts(m map[string]int64) int64 {
    var s int64
    for _, v := range m {
        s += v
    }
    return s
}

func SumFloats(m map[string]float64) float64 {
    var s float64
    for _, v := range m {
        s += v
    }
    return s
}

Dans le code ci-dessus, nous définissons Il y a deux fonctions : 

1. SumInts() calcule la somme des valeurs en tant que type int64 ; 2. SumFloats() calcule la somme des valeurs en tant que type float64 ;

La fonction ci-dessus n'est applicable qu'aux types int64 et float64 ; Je veux toujours Pour calculer int, float32, etc., vous devez recopier la fonction ci-dessus et modifier le type.

N'est-ce pas un peu gênant de faire cela, et le code est très volumineux ? Sans oublier qu'il existe de nombreux codes similaires dans le package standard précédent, comme le package Sort (sort.go) de la bibliothèque standard. Afin de réaliser le tri des différents types de tranches, on définit IntSlice, Float64Slice, StringSlice.

Étant donné que la version précédente de Go ne prenait pas en charge les génériques, elle ne peut être implémentée que de cette manière, qui est également la méthode la plus simple.

Avec les génériques, comment pouvons-nous implémenter une fonction pour calculer la somme des valeurs pour différents types de int64 et float64 ?

Fonction générique

Dans cette section, nous utilisons une fonction générique pour implémenter une carte dont la valeur est de type int64 en paramètre, ou une carte dont la valeur est de type float64 en paramètre.

Le code complet est le suivant :

func Sum[K comparable, V int64 | float64](m map[K]V "K comparable, V int64 | float64") V {
 var s V
 for _, v := range m {
  s += v
 }
 return s
}

func main() {
 ints := map[string]int64{
  "first":  1,
  "second": 2,
 }
 fmt.Println(Sum[string, int64](ints "string, int64"))

 floats := map[string]float64{
  "first":  35.98,
  "second": 26.99,
 }
 fmt.Println(Sum[string, float64](floats "string, float64"))
}

Dans le code ci-dessus, nous avons défini la fonction Sum(), qui est une fonction générique. Vous pouvez voir que la différence avec les fonctions ordinaires est qu'il existe un ensemble de méthodes entre les deux. nom de la fonction et la liste des paramètres de la fonction. Entre crochets [], il y a deux paramètres K et V entre crochets, qui sont appelés paramètres de type dans le langage Go. Immédiatement après K et V se trouvent restrictions de type, où comparable est. pré-déclaré par le langage Go et représente tout type A qui effectue les opérations == et !=. La restriction de type de V est l’une des int64 et float64. Le paramètre de fonction est m, le type est map[K]V et le type de retour est V.

L'appel d'une fonction est également un peu différent de l'appel d'une fonction ordinaire. Il y a un ensemble de crochets [] entre le nom de la fonction et les paramètres réels, indiquant le nom du type. Par exemple, lorsque la fonction Sum() est appelée pour la première fois, les noms de types sont respectivement string et int64. Ensuite, lorsque la fonction est exécutée, les types correspondants de K et V sont respectivement string et int64.

第二次调用该 Sum() 函数时，K、V 的类型分别是 string 和 float64。

通过泛型编程，我们就可以实现一个函数处理多种数据类型。

执行上面的代码输出：

3
62.97

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!