Conseils pour implémenter la réutilisation du code à l'aide de génériques dans Golang

Generics in Go permet la réutilisation du code en utilisant des paramètres de type pour créer des fonctions et des algorithmes réutilisables, réduisant ainsi la redondance et améliorant la maintenabilité du code. Les fonctions génériques permettent de comparer la valeur maximale de différents types (tels que int et string) et de vérifier si un élément est présent dans une tranche à l'aide d'algorithmes réutilisables, fournissant ainsi un outil puissant pour la réutilisation et la flexibilité du code.

Réutilisation de code à l'aide de génériques dans Go

Introduction

Les génériques permettent la création de code réutilisable sur différents types, réduisant ainsi la redondance et améliorant la maintenabilité du code. Go 1.18 introduit les génériques, fournissant de nouveaux outils puissants pour la réutilisation du code.

Créer des fonctions réutilisables à l'aide de génériques

Afin de créer une fonction générique, vous devez spécifier le paramètre de type à l'aide de crochets [] :

func Max[T comparable](x, y T) T {
    if x > y {
        return x
    }
    return y
}

Cette fonction utilise le paramètre de type T comme type d'élément à comparer. En raison de l'utilisation de la contrainte comparable, les fonctions ne peuvent être utilisées que sur des types comparables entre eux. T 用作比较的元素类型。由于使用 comparable 约束，函数只能用于可以相互比较的类型。

实战案例

比较不同类型的最大值

我们可以使用泛型函数 Max 来比较不同类型的最大值：

var x int = 10
var y string = "five"

fmt.Println(Max(x, y)) // 编译器错误，类型不匹配

要修复此错误，我们需要显式转换为匹配的类型：

yInt, _ := strconv.Atoi(y)
fmt.Println(Max(x, yInt)) // 输出：10

验证元素是否在切片中

泛型还可以用于编写可重用算法，例如验证元素是否存在于切片中：

func Contains[T comparable](slice []T, element T) bool {
    for _, v := range slice {
        if v == element {
            return true
        }
    }
    return false
}

实战案例

搜索整数切片中的元素

我们可以使用 Contains

Cas pratique

Comparaison des valeurs maximales de différents types

🎜🎜On peut utiliser la fonction générique Max pour comparer les valeurs maximales de différents types : 🎜

slice := []int{1, 2, 3}
fmt.Println(Contains(slice, 2)) // 输出：true

🎜Pour corrigez cette erreur, nous avons besoin d'une conversion explicite vers un type correspondant : 🎜rrreee🎜🎜Vérifiez qu'un élément est dans une tranche🎜🎜🎜Les génériques peuvent également être utilisés pour écrire des algorithmes réutilisables, comme vérifier qu'un élément est présent dans une tranche : 🎜rrreee🎜🎜Un exemple pratique🎜🎜🎜 🎜Recherche d'éléments dans une tranche d'entiers🎜🎜🎜On peut utiliser la fonction Contient pour rechercher des éléments dans une tranche d'entiers : 🎜rrreee🎜🎜Conclusion 🎜🎜🎜En utilisant des génériques dans Go, nous pouvons créer du code de réutilisation, réduire la redondance et améliorer la maintenabilité du code. Les génériques sont particulièrement utiles pour travailler avec différents types de données et écrire des algorithmes pouvant être appliqués à plusieurs types. 🎜

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!