Maison > développement back-end > Golang > Conseils pour implémenter la réutilisation du code à l'aide de génériques dans Golang

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

王林
Libérer: 2024-05-02 12:51:01
original
966 Les gens l'ont consulté

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.

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

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
}
Copier après la connexion

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)) // 编译器错误,类型不匹配
Copier après la connexion

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

yInt, _ := strconv.Atoi(y)
fmt.Println(Max(x, yInt)) // 输出:10
Copier après la connexion

验证元素是否在切片中

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

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

实战案例

搜索整数切片中的元素

我们可以使用 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
Copier après la connexion
🎜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!

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal