Comment comparer si deux structures, tranches ou cartes sont égales?

Je veux vérifier si deux structures, tranches et cartes sont égales.

Mais je rencontre des problèmes avec le code suivant. Voir mes commentaires aux lignes pertinentes.

package main

import (
    "fmt"
    "reflect"
)

type T struct {
    X int
    Y string
    Z []int
    M map[string]int
}

func main() {
    t1 := T{
        X: 1,
        Y: "lei",
        Z: []int{1, 2, 3},
        M: map[string]int{
            "a": 1,
            "b": 2,
        },
    }

    t2 := T{
        X: 1,
        Y: "lei",
        Z: []int{1, 2, 3},
        M: map[string]int{
            "a": 1,
            "b": 2,
        },
    }

    fmt.Println(t2 == t1)
    //error - invalid operation: t2 == t1 (struct containing []int cannot be compared)

    fmt.Println(reflect.ValueOf(t2) == reflect.ValueOf(t1))
    //false
    fmt.Println(reflect.TypeOf(t2) == reflect.TypeOf(t1))
    //true

    //Update: slice or map
    a1 := []int{1, 2, 3, 4}
    a2 := []int{1, 2, 3, 4}

    fmt.Println(a1 == a2)
    //invalid operation: a1 == a2 (slice can only be compared to nil)

    m1 := map[string]int{
        "a": 1,
        "b": 2,
    }
    m2 := map[string]int{
        "a": 1,
        "b": 2,
    }
    fmt.Println(m1 == m2)
    // m1 == m2 (map can only be compared to nil)
}

http://play.golang.org/p/AZIzW2WunI

Vous pouvez utiliser reflect.DeepEqual , ou vous pouvez implémenter votre propre fonction (qui en termes de performances serait meilleure que d'utiliser la réflexion):

http://play.golang.org/p/CPdfsYGNy_

m1 := map[string]int{   
    "a":1,
    "b":2,
}
m2 := map[string]int{   
    "a":1,
    "b":2,
}
fmt.Println(reflect.DeepEqual(m1, m2))

reflect.DeepEqual est souvent mal utilisé pour comparer deux structures similaires, comme dans votre question.

cmp.Equal est un meilleur outil pour comparer les structures.

Pour voir pourquoi la réflexion n'est pas judicieuse, regardons la documentation :

Les valeurs Struct sont profondément égales si leurs champs correspondants, à la fois exportés et non exportés, sont profondément égaux.

....

nombres, booléens, chaînes et canaux - sont profondément égaux s'ils sont égaux à l'aide de l'opérateur == de Go.

Si nous comparons deux time.Timevaleurs de la même heure UTC, t1 == t2sera faux si leur fuseau horaire de métadonnées est différent.

go-cmprecherche la Equal()méthode et l'utilise pour comparer correctement les temps.

Exemple:

m1 := map[string]int{
    "a": 1,
    "b": 2,
}
m2 := map[string]int{
    "a": 1,
    "b": 2,
}
fmt.Println(cmp.Equal(m1, m2)) // will result in true

Voici comment lancer votre propre fonction http://play.golang.org/p/Qgw7XuLNhb

func compare(a, b T) bool {
  if &a == &b {
    return true
  }
  if a.X != b.X || a.Y != b.Y {
    return false
  }
  if len(a.Z) != len(b.Z) || len(a.M) != len(b.M) {
    return false
  }
  for i, v := range a.Z {
    if b.Z[i] != v {
      return false
    }
  }
  for k, v := range a.M {
    if b.M[k] != v {
      return false
    }
  }
  return true
}

Depuis juillet 2017, vous pouvez utiliser cmp.Equalavec cmpopts.IgnoreFieldsoption.

func TestPerson(t *testing.T) {
    type person struct {
        ID   int
        Name string
    }

    p1 := person{ID: 1, Name: "john doe"}
    p2 := person{ID: 2, Name: "john doe"}
    println(cmp.Equal(p1, p2))
    println(cmp.Equal(p1, p2, cmpopts.IgnoreFields(person{}, "ID")))

    // Prints:
    // false
    // true
}

Si vous les comparer dans le test de l' unité , une alternative pratique est EqualValues fonctionnent en témoigner .