Comment vérifier efficacement l'égalité entre trois valeurs en Go ?

Moyens efficaces de vérifier l'égalité de trois valeurs

Dans Go, comparer plusieurs variables pour l'égalité peut être un défi. Bien que l'approche simple if a == b == c entraîne des erreurs de compilation, il existe plusieurs méthodes alternatives qui offrent des solutions élégantes et efficaces.

L'approche claire et concise

Les recommandations et La façon la plus concise de déterminer si trois valeurs sont identiques est :

<code class="go">if a == b && a == c {
    fmt.Println("All 3 are equal")
}</code>

Cette méthode exploite le fait que Go renvoie un booléen lors de la comparaison de deux valeurs, garantissant un code clair et lisible.

Alternatives pour l'expérimentation

Bien que la solution ci-dessus soit optimale, il existe diverses options créatives que l'on pourrait explorer pour l'expérimentation :

Carte sous forme d'ensemble :

<code class="go">if len(map[interface{}]int{a: 0, b: 0, c: 0}) == 1 {
    fmt.Println("Via a map set: all 3 are equal")
}</code>

Le concept derrière cette méthode est d'ajouter les valeurs comme clés à une carte, et si elles sont toutes égales, la carte ne contient qu'une seule clé, ce qui donne une longueur de 1.

Tableaux :

<code class="go">if [2]interface{}{a, b} == [2]interface{}{b, c} {
    fmt.Println("Via arrays: all 3 are equal")
}</code>

Les tableaux sont intrinsèquement comparables, nous permettant de comparer trois valeurs en utilisant ==. Cette approche, cependant, ne convient que pour comparer un nombre spécifique de valeurs.

Tricky Map :

<code class="go">if map[interface{}]bool{a: b == c}[b] {
    fmt.Println("Via a tricky map: all 3 are equal")
}</code>

Cette méthode utilise une carte pour attribuer le résultat de b == c à une clé, puis accède à la valeur associée à la même clé. Si a == b, le résultat de b == c est renvoyé, indiquant l'égalité.

Structs anonymes :

<code class="go">if struct{ a, b interface{} }{a, b} == struct{ a, b interface{} }{b, c} {
    fmt.Println("Via anonymous structs: all 3 are equal")
}</code>

Les structures imbriquées sont comparables, ce qui nous permet pour comparer trois valeurs avec une syntaxe concise.

Slices :

<code class="go">if reflect.DeepEqual([]interface{}{a, b}, []interface{}{b, c}) {
    fmt.Println("Via slices: all 3 are equal")
}</code>

Bien que les tranches elles-mêmes ne soient pas comparables, la fonction réflexion.DeepEqual() peut déterminer leur égalité , nous permettant de comparer leur contenu.

Fonction d'assistance :

<code class="go">func AllEquals(v ...interface{}) bool {
    if len(v) > 1 {
        a := v[0]
        for _, s := range v {
            if a != s {
                return false
            }
        }
    }
    return true
}</code>

Cette fonction réutilisable simplifie la comparaison de plusieurs valeurs en vérifiant de manière itérative l'égalité et en renvoyant un résultat booléen . Il peut être utilisé avec n'importe quel nombre de variables.

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!