Wie kann man vergleichen, ob zwei Strukturen, Slices oder Maps gleich sind?

Ich möchte überprüfen, ob zwei Strukturen, Slices und Maps gleich sind.

Aber ich habe Probleme mit dem folgenden Code. Siehe meine Kommentare in den entsprechenden Zeilen.

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

Sie können Reflect.DeepEqual verwenden oder Ihre eigene Funktion implementieren (welche Leistung wäre besser als Reflection):

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 wird oft fälschlicherweise verwendet, um zwei ähnliche Strukturen zu vergleichen, wie in Ihrer Frage.

cmp.Equal ist ein besseres Werkzeug zum Vergleichen von Strukturen.

Um zu sehen, warum Reflexion schlecht beraten ist, schauen wir uns die Dokumentation an :

Strukturwerte sind zutiefst gleich, wenn die entsprechenden Felder, sowohl exportiert als auch nicht exportiert, sehr gleich sind.

....

Zahlen, Bools, Strings und Kanäle - sind zutiefst gleich, wenn sie mit dem Operator == von Go gleich sind.

Wenn wir zwei time.TimeWerte derselben UTC-Zeit vergleichen, t1 == t2ist dies falsch, wenn ihre Metadaten-Zeitzone unterschiedlich ist.

go-cmpsucht nach der Equal()Methode und verwendet diese, um die Zeiten korrekt zu vergleichen.

Beispiel:

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

So rollen Sie Ihre eigene Funktion: 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
}

Seit Juli 2017 können Sie cmp.Equalmit cmpopts.IgnoreFieldsOption verwenden.

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
}

Wenn Sie sie sind zu vergleichen in Unit - Test , eine praktische Alternative ist EqualValues funktionieren in auszusagen .