Comprendre les concepts fondamentaux des génériques Golang

Les génériques Go permettent la création de types et de fonctions réutilisables sans modifier le code lui-même. Il comprend : Types génériques : utilisez des paramètres de type, permettant de spécifier des types de paramètres lors de la création du type (tels que []T, map[K]V). Fonctions génériques : lors de l'utilisation de paramètres de type, une liste de paramètres de type explicite doit être spécifiée. Contraintes : limitez l'utilisation de types génériques. Utilisez les mots-clés any, comparable et type interfaces pour spécifier des restrictions de type sur les paramètres de type. Avec ces concepts, il est possible de créer du code plus robuste et plus généraliste, comme des algorithmes de tri génériques.

Comprendre les concepts de base des génériques Golang

Préface
Les génériques sont une nouvelle fonctionnalité importante introduite dans Go 1.18, qui nous permet de créer des types réutilisables sans modifier le code lui-même et les fonctions. Ce didacticiel présentera les concepts de base des génériques dans Go et démontrera leur utilisation à travers des exemples pratiques.

Types génériques
Les types génériques paramétrent les types, nous permettant de spécifier les types de paramètres lors de la création du type. Ceci peut être réalisé en utilisant un créateur de type tel que []T ou map[K]V, où T et V code> sont respectivement des types de valeur et des types de clé. <code>[]T 或 map[K]V 等类型创建器来实现，其中 T 和 V 分别是值类型和键类型。

// 定义一个泛型 slice 类型
type MySlice[T any] []T

// 创建一个 MySlice[int] 实例
s := MySlice[int]{1, 2, 3}

泛型函数
泛型函数也可以使用类型参数，但它们还必须指定显式的类型参数列表。

// 定义一个将切片元素加倍的泛型函数
func Double[T ~int | ~float64](s []T) []T {
  for i, v := range s {
    s[i] = v * 2
  }
  return s
}

约束
约束允许我们通过指定类型参数的类型限制来限制泛型类型的用法。约束使用关键字 any、comparable

// 定义一个泛型 map 类型，键值为可比较类型
type MyMap[K comparable, V any] map[K]V

// 定义一个泛型函数来查找切片中的最大值
func Max[T any](s []T) T where T: ~int | ~float64 {
  max := s[0]
  for _, v := range s {
    if v > max {
      max = v
    }
  }
  return max
}

Fonctions génériquesLes fonctions génériques peuvent également prendre des paramètres de type, mais elles doivent également spécifier une liste de paramètres de type explicite.

// 定义泛型交换函数
func Swap[T any](s []T, i, j int) {
  temp := s[i]
  s[i] = s[j]
  s[j] = temp
}

// 定义泛型排序函数
func Sort[T any](s []T) where T: ~int | ~float64 | ~string {
  for i := 0; i < len(s); i++ {
    for j := i + 1; j < len(s); j++ {
      if s[j] < s[i] {
        Swap(s, i, j)
      }
    }
  }
}

ConstraintsLes contraintes nous permettent de restreindre l'utilisation de types génériques en spécifiant des restrictions de type sur les paramètres de type. Les contraintes sont implémentées à l'aide des mots-clés any, comparable et type interfaces.

rrreee

Exemple pratique🎜🎜Construisons un algorithme de tri simple à l'aide de génériques : 🎜rrreee🎜🎜Conclusion🎜🎜🎜Les génériques dans Go fournissent des outils puissants pour la réutilisation et la flexibilité du code. En comprenant le paramétrage des types, les contraintes et les exemples pratiques, les développeurs peuvent tirer parti de cette fonctionnalité pour créer un code plus robuste et plus polyvalent. 🎜

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!