Cas d'utilisation particuliers et techniques des génériques dans Golang

Cas d'utilisation spéciaux et astuces pour les génériques dans Go Utilisez des interfaces de type vides pour la vérification de type dynamique afin de vérifier les types d'exécution. Utilisez des paramètres de type génériques dans les collections pour créer des conteneurs de divers types. Implémentez des méthodes génériques pour effectuer des opérations courantes pour différents types de paramètres. Utilisez des contraintes de type pour implémenter des génériques spécifiques à un type et personnaliser les opérations pour les types spécifiés.

Cas d'utilisation spéciaux et conseils pour les génériques dans Go

Les génériques introduisent de nouvelles fonctionnalités qui permettent d'écrire du code flexible et efficace. Cet article explorera des cas d'utilisation et des techniques spéciales pour les génériques dans Go.

1. Utilisez une interface de type vide pour la vérification de type dynamique

any Le type peut représenter n'importe quel type. Cela nous permet d'effectuer une vérification de type dynamique basée sur les types déterminés au moment de l'exécution.

func isString(v any) bool {
    _, ok := v.(string)
    return ok
}

func main() {
    x := "hello"
    y := 10
    fmt.Println(isString(x)) // true
    fmt.Println(isString(y)) // false
}

2. Utilisation de types génériques sur les collections

Les paramètres de type génériques peuvent être utilisés dans les types de collection pour créer un conteneur de divers types.

type Stack[T any] []T

func (s *Stack[T]) Push(v T) {
    *s = append(*s, v)
}

func (s *Stack[T]) Pop() T {
    if s.IsEmpty() {
        panic("stack is empty")
    }

    v := (*s)[len(*s)-1]
    *s = (*s)[:len(*s)-1]
    return v
}

func main() {
    s := new(Stack[int])
    s.Push(10)
    s.Push(20)
    fmt.Println(s.Pop()) // 20
    fmt.Println(s.Pop()) // 10
}

3. Implémenter des méthodes génériques

Les méthodes génériques nous permettent d'implémenter des opérations communes pour différents types de paramètres.

type Num[T numeric] struct {
    V T
}

func (n *Num[T]) Add(other *Num[T]) {
    n.V += other.V
}

func main() {
    n1 := Num[int]{V: 10}
    n2 := Num[int]{V: 20}
    n1.Add(&n2)
    fmt.Println(n1.V) // 30

    // 可以使用其他数字类型
    n3 := Num[float64]{V: 3.14}
    n4 := Num[float64]{V: 2.71}
    n3.Add(&n4)
    fmt.Println(n3.V) // 5.85
}

4. Implémentez des génériques spécifiques à un type à l'aide de contraintes de type

Les contraintes de type limitent la portée des types génériques. Cela nous permet d'implémenter des opérations personnalisées pour des types spécifiques.

type Comparer[T comparable] interface {
    CompareTo(T) int
}

type IntComparer struct {
    V int
}

func (c *IntComparer) CompareTo(other IntComparer) int {
    return c.V - other.V
}

// IntSlice 实现 Comparer[IntComparer] 接口
type IntSlice []IntComparer

func (s IntSlice) Len() int {
    return len(s)
}

func (s IntSlice) Less(i, j int) bool {
    return s[i].CompareTo(s[j]) < 0
}

func (s IntSlice) Swap(i, j int) {
    s[i], s[j] = s[j], s[i]
}

func main() {
    s := IntSlice{{10}, {20}, {5}}
    sort.Sort(s)
    fmt.Println(s) // [{5} {10} {20}]
}

Ces cas d'utilisation et techniques spéciaux démontrent la puissance des génériques dans Go, permettant la création d'un code plus polyvalent, flexible et efficace.

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!