Comment vérifier élégamment l'égalité des valeurs dans Go ?

Des façons élégantes de vérifier l'égalité des valeurs dans Go

Dans Go, comparer l'égalité de plusieurs valeurs nécessite un examen attentif pour éviter les erreurs de compilation. Bien que l'approche simple if a == b == c entraîne une erreur de syntaxe, il existe plusieurs solutions élégantes à ce problème.

1. Conjonction avec les opérations booléennes :

Condenser la comparaison à l'aide de l'opérateur && offre une approche compacte et lisible :

<code class="go">if a == b && a == c {
    // All 3 values are equal
}</code>

2. Implémentation d'un ensemble de cartes :

L'utilisation d'une carte en tant qu'ensemble peut déterminer efficacement l'unicité des valeurs, car des valeurs égales donneront une carte avec une seule paire clé-valeur :

<code class="go">m := map[interface{}]int{a: 0, b: 0, c: 0}
if len(m) == 1 {
    // All 3 values are equal
}</code>

3. Comparabilité des tableaux :

Les tableaux dans Go sont comparables, offrant une solution simple :

<code class="go">arr1 := [2]interface{}{a, b}
arr2 := [2]interface{}{b, c}
if arr1 == arr2 {
    // All 3 values are equal
}</code>

4. Carte délicate :

Une approche créative consiste à utiliser une carte pour attribuer une valeur booléenne basée sur l'égalité, puis à la récupérer à l'aide d'une autre clé :

<code class="go">m := map[interface{}]bool{a: b == c}
if m[b] {
    // All 3 values are equal
}</code>

5. Structures anonymes :

Les structures sont également comparables dans Go, ce qui permet des comparaisons de valeurs concises :

<code class="go">s1 := struct{ a, b interface{} }{a, b}
s2 := struct{ a, b interface{} }{b, c}
if s1 == s2 {
    // All 3 values are equal
}</code>

6. (Nommées) Structures avec une fonction d'assistance :

La création d'une fonction d'assistance personnalisée peut améliorer l'élégance des comparaisons de structures :

<code class="go">type P struct{ a, b interface{} }

func AllEquals(s P, t P) bool {
    return s == t
}

// Usage:
if AllEquals(P{a, b}, P{b, c}) {
    // All 3 values are equal
}</code>

7. Tranches avec Reflect.DeepEqual() :

Les tranches, étant non comparables, nécessitent l'utilisation de la réflexion pour déterminer l'égalité :

<code class="go">slice1 := []interface{}{a, b}
slice2 := []interface{}{b, c}
if reflect.DeepEqual(slice1, slice2) {
    // All 3 values are equal
}</code>

Ces solutions fournissent diverses méthodes pour comparer avec élégance l'égalité de trois valeurs, répondant à différentes préférences et styles de code.

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!