Comment les fonctions génériques interagissent-elles avec les fonctions non génériques existantes dans Golang ?

Dans Go, les fonctions génériques peuvent interagir avec du code non générique en utilisant des assertions de type, des alias de type ou des interfaces vides. Les assertions de type permettent de convertir les valeurs en types spécifiques ; les alias de type créent des alias génériques de types existants et les interfaces vides peuvent représenter des variables de n'importe quel type ; Grâce à ces méthodes, les fonctions génériques peuvent accepter ou renvoyer des valeurs de types non génériques, permettant ainsi le traitement des données sur différents types.

Comment faire interagir des fonctions génériques avec des fonctions non génériques dans Go

Go Introduction des génériques depuis Go 1.18, ouvrant la porte à la réutilisation des types et du code d'algorithme. Mais comment le nouveau code générique interagit-il avec le code non générique existant ?

Utilisation des assertions de type

Les assertions de type fournissent un moyen de convertir une interface en une valeur d'un type spécifique. Cela peut être fait à l'aide d'une instruction switch :

func AnyToString(any interface{}) string {
    switch myString := any.(type) {
    case string:
        return myString
    default:
        return "Unknown"
    }
}

Cette fonction tente de convertir une valeur arbitraire en chaîne, renvoyant "Inconnu" s'il ne s'agit pas d'une chaîne.

Utiliser des alias de type

Les alias de type vous permettent de créer des alias pour des types existants. Cela nous permet de créer un alias générique pour un type non générique :

type MyString string

func GenericFunc[T MyString](t T) {}

Maintenant, nous pouvons utiliser le type non générique MyString dans une fonction générique GenericFunc : MyString 在泛型函数 GenericFunc 中：

GenericFunc(MyString("Hello"))

使用空的接口

空的接口可以表示任何类型的变量。这允许我们创建接受或返回任何类型值的泛型函数：

func GenericEmptyInterfaceFunc(empty interface{}) {}

我们可以使用任何类型的值调用此函数：

GenericEmptyInterfaceFunc(10)
GenericEmptyInterfaceFunc("Hello")

实战案例：实现泛型排序

让我们通过对列表进行排序来演示泛型代码与非泛型代码的交互。

// Sort is a generic function that sorts a slice of any type that implements sort.Interface.
func Sort[T sort.Interface](s []T) {
    sort.Sort(s)
}

// IntSlice implements sort.Interface for a slice of int.
type IntSlice []int

func (s IntSlice) Len() int { return len(s) }
func (s IntSlice) Less(i, j int) bool { return s[i] < s[j] }
func (s IntSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

// StringSlice implements sort.Interface for a slice of string.
type StringSlice []string

func (s StringSlice) Len() int { return len(s) }
func (s StringSlice) Less(i, j int) bool { return s[i] < s[j] }
func (s StringSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

func main() {
    intSlice := IntSlice{10, 5, 7, 3, 11}
    Sort(intSlice)
    fmt.Println(intSlice) // Output: [3 5 7 10 11]

    stringSlice := StringSlice{"Hello", "World", "Go", "Golang"}
    Sort(stringSlice)
    fmt.Println(stringSlice) // Output: [Go Golang Hello World]
}

此代码演示了如何使用泛型函数 Sort rrreee

🎜Utilisez une interface vide🎜🎜🎜Une interface vide peut représenter n'importe quel type de variable. Cela nous permet de créer des fonctions génériques qui acceptent ou renvoient tout type de valeur : 🎜rrreee🎜 Nous pouvons appeler cette fonction avec n'importe quel type de valeur : 🎜rrreee🎜🎜 Exemple pratique : implémentation du tri générique 🎜🎜🎜 Trions la liste par Pour démontrer l'interaction entre le code générique et le code non générique. 🎜rrreee🎜Ce code montre comment utiliser la fonction générique Trier pour trier différentes listes de valeurs en fonction d'un type personnalisé. 🎜

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!