Quelle est la différence entre les contraintes « comparables » et « ordonnées » dans les génériques Go pour les comparaisons de types ?

Contraintes comparables et opérateurs ordonnés dans les génériques Go

Dans les génériques Go, la contrainte comparable restreint les types qui prennent en charge les opérateurs d'égalité (== et !=), tandis que les opérateurs ordonnés (<, >, <= et >=) nécessitent l'attribut Ordonné contrainte.

Considérez le code suivant :

import "fmt"

type numbers interface {
    int | int8 | int16 | int32 | int64 | float32 | float64
}

func getBiggerNumber[T numbers](t1, t2 T) T {
    if t1 > t2 {
        return t1
    }
    return t2
}

func getBiggerNumberWithComparable[T comparable](t1, t2 T) T {
    if t1 > t2 { // Compile error
        return t1
    }
    return t2
}

func main() {
    fmt.Println(getBiggerNumber(2.5, -4.0))
    fmt.Println(getBiggerNumberWithComparable(2.5, -4.0))
}

L'erreur dans getBiggerNumberWithComparable se produit car comparable ne garantit pas la comparaison des commandes. Il inclut des types de clés de carte qui ne prennent pas en charge la commande.

Solution pour Go 1.18 à 1.20

Avant Go 1.21, utilisez des contraintes.Ordonné :

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

func getBiggerNumberWithOrdered[T constraints.Ordered](t1, t2 T) T {
    if t1 > t2 {
        return t1
    }
    return t2
}

Solution pour Go 1.21

Dans Go 1.21 et versions ultérieures, utilisez cmp.Ordered :

import (
    "fmt"

    "golang.org/x/exp/constraints"
    "github.com/google/go-cmp/cmp"
)

func getBiggerNumberWithOrdered[T cmp.Ordered](t1, t2 T) T {
    if cmp.Less(t1, t2) {
        return t2
    }
    return t1
}

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!